ably 1.1.6 → 1.2.0

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'

data/spec/support/test_app.rb

@@ -59,7 +59,7 @@ class TestApp
 
     url = "#{sandbox_client.endpoint}/apps/#{app_id}"
 
-    basic_auth = Base64.encode64(api_key).chomp
+    basic_auth = Base64.urlsafe_encode64(api_key).chomp
     headers    = { "Authorization" => "Basic #{basic_auth}" }
 
     Faraday.delete(url, nil, headers)

data/spec/unit/models/delta_extras_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Models::DeltaExtras do
+  subject { described_class.new({ format: 'vcdiff', from: '1234-4567-8910-1001-1111'}) }
+
+  it 'should have `from` attribute' do
+    expect(subject.from).to eq('1234-4567-8910-1001-1111')
+  end
+
+  it 'should have `format` attribute' do
+    expect(subject.format).to eq('vcdiff')
+  end
+end

data/spec/unit/models/error_info_spec.rb

@@ -5,7 +5,7 @@ describe Ably::Models::ErrorInfo do
   subject { Ably::Models::ErrorInfo }
 
   context '#TI1, #TI4' do
-    it_behaves_like 'a model', with_simple_attributes: %w(code status_code href message) do
+    it_behaves_like 'a model', with_simple_attributes: %w(code status_code href message request_id cause) do
       let(:model_args) { [] }
     end
   end
@@ -18,6 +18,22 @@ describe Ably::Models::ErrorInfo do
     end
   end
 
+  context '#request_id #RSC7c' do
+    subject { Ably::Models::ErrorInfo.new('request_id' => '123-456-789-001') }
+
+    it 'should return request ID' do
+      expect(subject.request_id).to eql('123-456-789-001')
+    end
+  end
+
+  context '#cause #TI1' do
+    subject { Ably::Models::ErrorInfo.new('cause' => Ably::Models::ErrorInfo.new({})) }
+
+    it 'should return cause attribute' do
+      expect(subject.cause).to be_kind_of(Ably::Models::ErrorInfo)
+    end
+  end
+
   context 'log entries container help link #TI5' do
     context 'without an error code' do
       subject { Ably::Models::ErrorInfo.new('statusCode' => 401) }

data/spec/unit/models/message_spec.rb

@@ -211,6 +211,79 @@ 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
+
+  describe '#protocol_message_index (#RTL21)' do
+    let(:messages) { [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }] }
+
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new({ action: 1 }.merge(messages: messages))
+    end
+
+    it 'should return correct protocol_message_index' do
+      expect(protocol_message.messages[0].protocol_message_index).to eq(0)
+      expect(protocol_message.messages[1].protocol_message_index).to eq(1)
+      expect(protocol_message.messages[2].protocol_message_index).to eq(2)
+    end
+  end
+
   context 'from REST request with embedded fields', :api_private do
     let(:id)                  { random_str }
     let(:protocol_message_id) { random_str }
@@ -547,4 +620,28 @@ describe Ably::Models::Message do
       end
     end
   end
+
+  context '#delta_extras (TM2i)' do
+    let(:delta_extras) { message.delta_extras }
+
+    context 'when delta' do
+      let(:message) { subject.new({ extras: { delta: { from: '1234-1234-5678-9009', format: 'vcdiff' } } }) }
+
+      it 'should return vcdiff format' do
+        expect(delta_extras.format).to eq('vcdiff')
+      end
+
+      it 'should return 1234-1234-5678-9009 message id' do
+        expect(delta_extras.from).to eq('1234-1234-5678-9009')
+      end
+    end
+
+    context 'when no delta' do
+      let(:message) { subject.new({ extras: {} }) }
+
+      it 'should return nil' do
+        expect(delta_extras).to eq(nil)
+      end
+    end
+  end
 end

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

@@ -10,9 +10,9 @@ describe Ably::Models::ProtocolMessage do
     subject.new({ action: 1 }.merge(options))
   end
 
-  # TR4n, TR4b, TR4c, TR4d, TR4e
+  # TR4n, TR4b, TR4c, TR4d
   it_behaves_like 'a model',
-    with_simple_attributes: %w(id channel channel_serial connection_id connection_key),
+    with_simple_attributes: %w(id channel channel_serial connection_id),
     base_model_options: { action: 1 } do
 
     let(:model_args) { [] }
@@ -176,6 +176,28 @@ describe Ably::Models::ProtocolMessage do
         end
       end
 
+      context 'when attach resumed flag' do
+        context 'flags is 34' do
+          let(:protocol_message) { new_protocol_message(flags: 34) }
+
+          it '#has_attach_resume_flag? is true' do
+            expect(protocol_message.has_attach_resume_flag?).to be_truthy
+          end
+
+          it '#has_attach_presence_flag? is false' do
+            expect(protocol_message.has_attach_presence_flag?).to be_falsey
+          end
+        end
+
+        context 'flags is 0' do
+          let(:protocol_message) { new_protocol_message(flags: 0) }
+
+          it 'should raise an exception if flags is a float number' do
+            expect(protocol_message.has_attach_resume_flag?).to be_falsy
+          end
+        end
+      end
+
       context 'when channel resumed and presence flags present' do
         let(:protocol_message) { new_protocol_message(flags: 5) }
 
@@ -201,6 +223,24 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
+    context '#params (#RTL4k1)' do
+      let(:params) do
+        { foo: :bar }
+      end
+
+      context 'when present' do
+        specify do
+          expect(new_protocol_message({ params: params }).params).to eq(params)
+        end
+      end
+
+      context 'when empty' do
+        specify do
+          expect(new_protocol_message({}).params).to eq({})
+        end
+      end
+    end
+
     context '#has_connection_serial?' do
       context 'without connection_serial' do
         let(:protocol_message) { new_protocol_message({}) }
@@ -308,6 +348,26 @@ describe Ably::Models::ProtocolMessage do
       end
     end
 
+    context '#messages (#RTL21)' do
+      let(:protocol_message) do
+        new_protocol_message(messages: [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }])
+      end
+
+      before do
+        message = Ably::Models::Message(name: 'test4')
+        message.assign_to_protocol_message(protocol_message)
+        protocol_message.add_message(message)
+      end
+
+      it 'contains Message objects in ascending order' do
+        expect(protocol_message.messages.count).to eql(4)
+        protocol_message.messages.each_with_index do |message, index|
+          expect(message.protocol_message_index).to eql(index)
+          expect(message.name).to include('test')
+        end
+      end
+    end
+
     context '#presence (#TR4l)' do
       let(:protocol_message) { new_protocol_message(presence: [{ action: 1, data: 'test' }]) }
 
@@ -318,6 +378,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 }
 
@@ -369,41 +477,27 @@ describe Ably::Models::ProtocolMessage do
         end
       end
     end
-
-    context '#connection_key (#TR4e)' do
-      context 'existing only in #connection_details.connection_key' do
-        let(:protocol_message) { new_protocol_message(connectionDetails: { connectionKey: 'key' }) }
-
-        it 'is returned' do
-          expect(protocol_message.connection_key).to eql('key')
-        end
-      end
-
-      context 'existing in both #connection_key and #connection_details.connection_key' do
-        let(:protocol_message) { new_protocol_message(connectionKey: 'deprecated', connectionDetails: { connectionKey: 'key' }) }
-
-        it 'returns #connection_details.connection_key as #connection_key will be deprecated > 0.8' do
-          expect(protocol_message.connection_key).to eql('key')
-        end
-      end
-    end
   end
 
   context '#to_json', :api_private do
     let(:json_object) { JSON.parse(model.to_json) }
-    let(:message) { { 'name' => 'event', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message1) { { 'name' => 'event1', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message2) { { 'name' => 'event2', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message3) { { 'name' => 'event3', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
     let(:attached_action) { Ably::Models::ProtocolMessage::ACTION.Attached }
     let(:message_action) { Ably::Models::ProtocolMessage::ACTION.Message }
 
     context 'with valid data' do
-      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message] }) }
+      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message1, message2, message3] }) }
 
       it 'converts the attribute back to Java mixedCase notation using string keys' do
         expect(json_object["channelSerial"]).to eql('unique')
       end
 
       it 'populates the messages' do
-        expect(json_object["messages"].first).to include(message)
+        expect(json_object["messages"][0]).to include(message1)
+        expect(json_object["messages"][1]).to include(message2)
+        expect(json_object["messages"][2]).to include(message3)
       end
     end
 
@@ -416,7 +510,7 @@ describe Ably::Models::ProtocolMessage do
     end
 
     context 'is aliased by #to_s' do
-      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message], :timestamp => as_since_epoch(Time.now) }) }
+      let(:model) { new_protocol_message({ :action => attached_action, :channelSerial => 'unique', messages: [message1, message2, message3], :timestamp => as_since_epoch(Time.now) }) }
 
       specify do
         expect(json_object).to eql(JSON.parse("#{model}"))
@@ -425,14 +519,18 @@ describe Ably::Models::ProtocolMessage do
   end
 
   context '#to_msgpack', :api_private do
-    let(:model)    { new_protocol_message({ :connectionSerial => 'unique', messages: [message] }) }
-    let(:message)  { { 'name' => 'event', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:model)    { new_protocol_message({ :connectionSerial => 'unique', messages: [message1, message2, message3] }) }
+    let(:message1)  { { 'name' => 'event1', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message2)  { { 'name' => 'event2', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
+    let(:message3)  { { 'name' => 'event3', 'clientId' => 'joe', 'timestamp' => as_since_epoch(Time.now) } }
     let(:packed)   { model.to_msgpack }
     let(:unpacked) { MessagePack.unpack(packed) }
 
     it 'returns a unpackable msgpack object' do
       expect(unpacked['connectionSerial']).to eq('unique')
-      expect(unpacked['messages'][0]['name']).to eq('event')
+      expect(unpacked['messages'][0]['name']).to eq('event1')
+      expect(unpacked['messages'][1]['name']).to eq('event2')
+      expect(unpacked['messages'][2]['name']).to eq('event3')
     end
   end
 end

data/spec/unit/models/token_details_spec.rb

@@ -80,6 +80,20 @@ describe Ably::Models::TokenDetails do
           expect(subject.expired?).to eql(false)
         end
       end
+
+      context 'with :from attribute' do
+        subject { Ably::Models::TokenDetails.new(expires: expire_time) }
+
+        let(:server_offset_time) { 2 * 60 * 60 } # 2 hours
+
+        it 'is false' do
+          expect(subject.expired?(from: (Time.now - server_offset_time))).to eql(false)
+        end
+
+        it 'is true' do
+          expect(subject.expired?(from: Time.now)).to eql(true)
+        end
+      end
     end
   end
 

data/spec/unit/realtime/channel_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 require 'shared/protocol_msgbus_behaviour'
 
 describe Ably::Realtime::Channel do
-  let(:client)       { double('client').as_null_object }
+  let(:client)       { Ably::Realtime::Client.new(token: 'valid') }
   let(:channel_name) { 'test' }
 
   subject do
@@ -68,9 +68,10 @@ 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(:enqueue_messages_on_connection).and_return(message)
       allow(subject).to receive(:create_message).and_return(message)
       allow(subject).to receive(:attach).and_return(:true)
     end

data/spec/unit/realtime/channels_spec.rb

@@ -3,39 +3,77 @@ require 'spec_helper'
 
 describe Ably::Realtime::Channels do
   let(:connection) { instance_double('Ably::Realtime::Connection', unsafe_on: true, on_resume: true) }
-  let(:client) { instance_double('Ably::Realtime::Client', connection: connection, client_id: 'clientId') }
+  let(:client) do
+    instance_double('Ably::Realtime::Client', connection: connection, client_id: 'clientId', logger: double('logger').as_null_object)
+  end
   let(:channel_name) { 'unique' }
-  let(:options) { { 'bizarre' => 'value' } }
+  let(:options) do
+    { params: { bizarre: 'value' } }
+  end
 
   subject { Ably::Realtime::Channels.new(client) }
 
   context 'creating channels' do
     context '#get' do
-      it 'creates a channel if it does not exist' do
-        expect(Ably::Realtime::Channel).to receive(:new).with(client, channel_name, options)
-        subject.get(channel_name, options)
+      context "when channel doesn't exist" do
+        shared_examples 'creates a channel' do
+          it 'creates a channel (RTS3a)' do
+            expect(Ably::Realtime::Channel).to receive(:new).with(client, channel_name, channel_options)
+            subject.get(channel_name, channel_options)
+          end
+        end
+
+        describe 'hash' do
+          let(:channel_options) { options }
+          it { expect(channel_options).to be_a(Hash) }
+
+          include_examples 'creates a channel'
+        end
+
+        describe 'ChannelOptions object' do
+          let(:channel_options) { Ably::Models::ChannelOptions.new(options) }
+          it { expect(channel_options).to be_a(Ably::Models::ChannelOptions) }
+
+          include_examples 'creates a channel'
+        end
       end
 
       context 'when an existing channel exists' do
-        it 'will reuse a channel object if it exists' do
-          channel = subject.get(channel_name, options)
-          expect(channel).to be_a(Ably::Realtime::Channel)
-          expect(subject.get(channel_name, options).object_id).to eql(channel.object_id)
+        shared_examples 'reuse a channel object if it exists' do
+          it 'will reuse a channel object if it exists (RTS3a)' do
+            channel = subject.get(channel_name, channel_options)
+            expect(channel).to be_a(Ably::Realtime::Channel)
+            expect(subject.get(channel_name, channel_options).object_id).to eql(channel.object_id)
+          end
+        end
+
+        describe 'hash' do
+          let(:channel_options) { options }
+          it { expect(channel_options).to be_a(Hash) }
+
+          include_examples 'reuse a channel object if it exists'
+        end
+
+        describe 'ChannelOptions object' do
+          let(:channel_options) { Ably::Models::ChannelOptions.new(options) }
+          it { expect(channel_options).to be_a(Ably::Models::ChannelOptions) }
+
+          include_examples 'reuse a channel object if it exists'
         end
 
-        it 'will update the options on the channel if provided' do
+        it 'will update the options on the channel if provided (RSN3c)' do
           channel = subject.get(channel_name, options)
-          expect(channel.options).to eql(options)
-          expect(channel.options).to_not include(:encrypted)
+          expect(channel.options.to_h).to eq(options)
+          expect(channel.options.to_h).to_not include(:encrypted)
           subject.get(channel_name, encrypted: true)
-          expect(channel.options[:encrypted]).to eql(true)
+          expect(channel.options[:encrypted]).to eq(true)
         end
 
         it 'will leave the options intact on the channel if not provided' do
           channel = subject.get(channel_name, options)
-          expect(channel.options).to eql(options)
+          expect(channel.options.to_h).to eq(options)
           subject.get(channel_name)
-          expect(channel.options).to eql(options)
+          expect(channel.options.to_h).to eq(options)
         end
       end
     end

data/spec/unit/realtime/incoming_message_dispatcher_spec.rb

@@ -32,5 +32,43 @@ describe Ably::Realtime::Client::IncomingMessageDispatcher, :api_private do
       expect(subject).to receive_message_chain(:logger, :warn)
       msgbus.publish :protocol_message, Ably::Models::ProtocolMessage.new(:action => :attached, channel: 'unknown')
     end
+
+    context 'TO3l8' do
+      context 'on action presence' do
+        let(:presence) { 101.times.map { { data: 'x' * 655 } } }
+
+        let(:protocol_message) do
+          Ably::Models::ProtocolMessage.new(action: :presence, channel: 'default', presence: presence, connection_serial: 123123123)
+        end
+
+        it 'should raise a protocol error when message size exceeded 65536 bytes' do
+          allow(connection).to receive(:serial).and_return(12312312)
+          allow(subject).to receive(:update_connection_recovery_info)
+          allow(subject).to receive_message_chain(:logger, :debug)
+          allow(subject).to receive_message_chain(:logger, :warn)
+          expect(subject).to receive_message_chain(:logger, :fatal)
+
+          msgbus.publish :protocol_message, protocol_message
+        end
+      end
+
+      context 'on action message' do
+        let(:messages) { 101.times.map { { data: 'x' * 655 } } }
+
+        let(:protocol_message) do
+          Ably::Models::ProtocolMessage.new(action: :message, channel: 'default', messages: messages, connection_serial: 123123123)
+        end
+
+        it 'should raise a protocol error when message size exceeded 65536 bytes' do
+          allow(connection).to receive(:serial).and_return(12312312)
+          allow(subject).to receive(:update_connection_recovery_info)
+          allow(subject).to receive_message_chain(:logger, :debug)
+          allow(subject).to receive_message_chain(:logger, :warn)
+          expect(subject).to receive_message_chain(:logger, :fatal)
+
+          msgbus.publish :protocol_message, protocol_message
+        end
+      end
+    end
   end
 end