ably 0.6.2 → 0.7.0

data/spec/unit/models/error_info_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'support/model_helper'
+require 'shared/model_behaviour'
 
 describe Ably::Models::ErrorInfo do
   subject { Ably::Models::ErrorInfo }

data/spec/unit/models/idiomatic_ruby_wrapper_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
-require 'securerandom'
 
-describe Ably::Models::IdiomaticRubyWrapper do
+describe Ably::Models::IdiomaticRubyWrapper, :api_private do
   include Ably::Modules::Conversions
 
   let(:mixed_case_data) do
@@ -107,7 +106,7 @@ describe Ably::Models::IdiomaticRubyWrapper do
         'lowercasestring'   => 'lowercasestringValue'
       }
     end
-    let(:unique_value) { SecureRandom.hex }
+    let(:unique_value) { random_str }
 
     subject { Ably::Models::IdiomaticRubyWrapper.new(data) }
 

data/spec/unit/models/message_encoders/base64_spec.rb

@@ -5,7 +5,7 @@ require 'msgpack'
 require 'ably/models/message_encoders/base64'
 
 describe Ably::Models::MessageEncoders::Base64 do
-  let(:decoded_data)        { SecureRandom.hex(32) }
+  let(:decoded_data)        { random_str(32) }
   let(:base64_data)         { Base64.encode64(decoded_data) }
   let(:binary_data)         { MessagePack.pack(decoded_data) }
   let(:base64_binary_data)  { Base64.encode64(binary_data) }
@@ -111,7 +111,7 @@ describe Ably::Models::MessageEncoders::Base64 do
       end
 
       context 'message with empty binary string payload' do
-        let(:message) { { data: ''.force_encoding(Encoding::ASCII_8BIT), encoding: nil } }
+        let(:message) { { data: ''.encode(Encoding::ASCII_8BIT), encoding: nil } }
 
         it 'leaves the message data intact' do
           expect(message[:data]).to eql('')

data/spec/unit/models/message_encoders/cipher_spec.rb

@@ -3,11 +3,11 @@ require 'ably/models/message_encoders/cipher'
 require 'msgpack'
 
 describe Ably::Models::MessageEncoders::Cipher do
-  let(:secret_key)          { SecureRandom.hex(64) }
+  let(:secret_key)          { random_str(64) }
   let(:crypto_options)      { { key: secret_key, algorithm: 'AES', mode: 'CBC', key_length: 128 } }
   let(:crypto)              { Ably::Util::Crypto.new(cipher_params) }
 
-  let(:decoded_data)        { SecureRandom.hex(32) }
+  let(:decoded_data)        { random_str(32) }
   let(:cipher_data)         { crypto.encrypt(decoded_data) }
 
   let(:binary_data)         { MessagePack.pack(decoded_data) }

data/spec/unit/models/message_encoders/utf8_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 require 'ably/models/message_encoders/utf8'
 
 describe Ably::Models::MessageEncoders::Utf8 do
-  let(:string_ascii)        { 'string'.force_encoding(Encoding::ASCII_8BIT) }
-  let(:string_utf8)         { 'string'.force_encoding(Encoding::UTF_8) }
+  let(:string_ascii)        { 'string'.encode(Encoding::ASCII_8BIT) }
+  let(:string_utf8)         { 'string'.encode(Encoding::UTF_8) }
 
   let(:client)              { instance_double('Ably::Realtime::Client') }
 
@@ -53,48 +53,4 @@ describe Ably::Models::MessageEncoders::Utf8 do
       end
     end
   end
-
-  context '#encode' do
-    before do
-      subject.encode message, {}
-    end
-
-    context 'message with json payload' do
-      let(:message) { { data: string_ascii, encoding: 'json' } }
-
-      it 'sets the cencoding' do
-        expect(message[:data]).to eql(string_utf8)
-        expect(message[:data].encoding).to eql(Encoding::UTF_8)
-      end
-
-      it 'adds the encoding' do
-        expect(message[:encoding]).to eql('json/utf-8')
-      end
-    end
-
-
-    context 'message with string payload and no encoding' do
-      let(:message) { { data: string_ascii, encoding: nil } }
-
-      it 'leaves the message data intact' do
-        expect(message[:data]).to eql(string_ascii)
-      end
-
-      it 'leaves the encoding intact' do
-        expect(message[:encoding]).to eql(nil)
-      end
-    end
-
-    context 'message with string payload and UTF-8 encoding' do
-      let(:message) { { data: string_ascii, encoding: 'utf-8' } }
-
-      it 'leaves the message data intact' do
-        expect(message[:data]).to eql(string_ascii)
-      end
-
-      it 'leaves the encoding intact' do
-        expect(message[:encoding]).to eql('utf-8')
-      end
-    end
-  end
 end

data/spec/unit/models/message_spec.rb

@@ -1,5 +1,6 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'support/model_helper'
+require 'shared/model_behaviour'
 require 'base64'
 require 'msgpack'
 
@@ -16,13 +17,56 @@ describe Ably::Models::Message do
 
   context '#timestamp' do
     let(:model) { subject.new({}, protocol_message) }
-    it 'retrieves attribute :timestamp from ProtocolMessage' do
+
+    it 'retrieves attribute :timestamp as Time object from ProtocolMessage' do
       expect(model.timestamp).to be_a(Time)
       expect(model.timestamp.to_i).to be_within(1).of(Time.now.to_i)
     end
   end
 
-  context 'Java naming' do
+  context '#connection_id attribute' do
+    let(:protocol_connection_id) { random_str }
+    let(:protocol_message) { Ably::Models::ProtocolMessage.new('connectionId' => protocol_connection_id, action: 1, timestamp: protocol_message_timestamp) }
+    let(:model_connection_id) { random_str }
+
+    context 'when this model has a connectionId attribute' do
+      context 'but no protocol message' do
+        let(:model) { subject.new('connectionId' => model_connection_id ) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+
+      context 'with a protocol message with a different connectionId' do
+        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+    end
+
+    context 'when this model has no connectionId attribute' do
+      context 'and no protocol message' do
+        let(:model) { subject.new({ }) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to be_nil
+        end
+      end
+
+      context 'with a protocol message with a connectionId' do
+        let(:model) { subject.new({ }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(protocol_connection_id)
+        end
+      end
+    end
+  end
+
+  context 'Java naming', :api_private do
     let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
 
     it 'converts the attribute to ruby symbol naming convention' do
@@ -30,7 +74,71 @@ describe Ably::Models::Message do
     end
   end
 
-  context '#to_json' do
+  context 'initialized with' do
+    %w(name client_id encoding).each do |attribute|
+      context ":#{attribute}" do
+        let(:encoded_value)   { value.encode(encoding) }
+        let(:value)           { random_str }
+        let(:options)         { { attribute.to_sym => encoded_value } }
+        let(:model)           { subject.new(options, protocol_message) }
+        let(:model_attribute) { model.public_send(attribute) }
+
+        context 'as UTF_8 string' do
+          let(:encoding) { Encoding::UTF_8 }
+
+          it 'is permitted' do
+            expect(model_attribute).to eql(encoded_value)
+          end
+
+          it 'remains as UTF-8' do
+            expect(model_attribute.encoding).to eql(encoding)
+          end
+        end
+
+        context 'as SHIFT_JIS string' do
+          let(:encoding) { Encoding::SHIFT_JIS }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as ASCII_8BIT string' do
+          let(:encoding) { Encoding::ASCII_8BIT }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as Integer' do
+          let(:encoded_value) { 1 }
+
+          it 'raises an argument error' do
+            expect { model_attribute }.to raise_error ArgumentError, /must be a String/
+          end
+        end
+
+        context 'as Nil' do
+          let(:encoded_value) { nil }
+
+          it 'is permitted' do
+            expect(model_attribute).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  context '#to_json', :api_private do
     let(:json_object) { JSON.parse(model.to_json) }
 
     context 'with valid data' do
@@ -50,7 +158,7 @@ describe Ably::Models::Message do
     end
 
     context 'with binary data' do
-      let(:data) { MessagePack.pack(SecureRandom.hex(32)) }
+      let(:data) { MessagePack.pack(random_str(32)) }
       let(:model) { subject.new({ name: 'test', data: data }, protocol_message) }
 
       it 'encodes as Base64 so that it can be converted to UTF-8 automatically by JSON#dump' do
@@ -63,13 +171,25 @@ describe Ably::Models::Message do
     end
   end
 
-  context 'from REST request with embedded fields' do
-    let(:id) { SecureRandom.hex }
-    let(:message_time) { Time.now + 60 }
-    let(:timestamp) { as_since_epoch(message_time) }
-    let(:model) { subject.new(id: id, timestamp: timestamp) }
+  context 'from REST request with embedded fields', :api_private do
+    let(:id)                  { random_str }
+    let(:protocol_message_id) { random_str }
+    let(:message_time)        { Time.now + 60 }
+    let(:message_timestamp)   { as_since_epoch(message_time) }
+    let(:protocol_time)       { Time.now }
+    let(:protocol_timestamp)  { as_since_epoch(protocol_time) }
+
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new({
+        action: :message,
+        timestamp: protocol_timestamp,
+        id: protocol_message_id
+      })
+    end
 
     context 'with protocol message' do
+      let(:model) { subject.new({ id: id, timestamp: message_timestamp }, protocol_message) }
+
       specify '#id prefers embedded ID' do
         expect(model.id).to eql(id)
       end
@@ -80,6 +200,8 @@ describe Ably::Models::Message do
     end
 
     context 'without protocol message' do
+      let(:model) { subject.new(id: id, timestamp: message_timestamp) }
+
       specify '#id uses embedded ID' do
         expect(model.id).to eql(id)
       end
@@ -90,10 +212,10 @@ describe Ably::Models::Message do
     end
   end
 
-  context 'part of ProtocolMessage' do
+  context 'part of ProtocolMessage', :api_private do
     let(:ably_time) { Time.now + 5 }
-    let(:message_serial) { SecureRandom.random_number(1_000_000) }
-    let(:connection_id) { SecureRandom.hex }
+    let(:message_serial) { random_int_str(1_000_000) }
+    let(:connection_id) { random_str }
 
     let(:message_0_payload) do
       {
@@ -117,7 +239,7 @@ describe Ably::Models::Message do
       }
     end
 
-    let(:protocol_message_id) { SecureRandom.hex }
+    let(:protocol_message_id) { random_str }
     let(:protocol_message) do
       Ably::Models::ProtocolMessage.new({
         action: :message,
@@ -150,9 +272,32 @@ describe Ably::Models::Message do
     it 'should not allow changes to the payload' do
       expect { message_0.data["test"] = true }.to raise_error RuntimeError, /can't modify frozen Hash/
     end
+
+    context 'with identical message objects' do
+      let(:protocol_message) do
+        Ably::Models::ProtocolMessage.new({
+          action: :message,
+          timestamp: ably_time.to_i,
+          msg_serial: message_serial,
+          id: protocol_message_id,
+          messages: [
+            message_0_json, message_0_json, message_0_json
+          ]
+        })
+      end
+
+      it 'provide a unique ID:index' do
+        expect(protocol_message.messages.map(&:id).uniq.count).to eql(3)
+      end
+
+      it 'recognises the index based on the object ID as opposed to message payload' do
+        expect(protocol_message.messages.first.id).to match(/0$/)
+        expect(protocol_message.messages.last.id).to match(/2$/)
+      end
+    end
   end
 
-  context 'Message conversion method' do
+  context 'Message conversion method', :api_private do
     let(:json) { { name: 'test', data: 'conversion' } }
 
     context 'with JSON' do

data/spec/unit/models/paginated_resource_spec.rb

@@ -58,7 +58,7 @@ describe Ably::Models::PaginatedResource do
     expect(subject.last[:id]).to eql(body[1][:id])
   end
 
-  context 'with coercion' do
+  context 'with coercion', :api_private do
     let(:paginated_resource_options) { { coerce_into: 'OpenStruct' } }
 
     it 'returns coerced objects' do
@@ -67,7 +67,7 @@ describe Ably::Models::PaginatedResource do
     end
   end
 
-  context 'paged transformations' do
+  context 'paged transformations', :api_private do
     let(:headers) do
       {
         'link' => [
@@ -114,43 +114,45 @@ describe Ably::Models::PaginatedResource do
       end
     end
 
-    context 'with option async_blocking_operations: true' do
-      include RSpec::EventMachine
+    if defined?(EventMachine)
+      context 'with option async_blocking_operations: true' do
+        include RSpec::EventMachine
 
-      subject do
-        paginated_resource_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
-      end
-
-      context '#next_page' do
-        it 'returns a deferrable object' do
-          run_reactor do
-            expect(subject.next_page).to be_a(EventMachine::Deferrable)
-            stop_reactor
-          end
+        subject do
+          paginated_resource_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
         end
 
-        it 'allows a success callback block to be added' do
-          run_reactor do
-            subject.next_page do |paginated_resource|
-              expect(paginated_resource).to be_a(Ably::Models::PaginatedResource)
+        context '#next_page' do
+          it 'returns a deferrable object' do
+            run_reactor do
+              expect(subject.next_page).to be_a(EventMachine::Deferrable)
               stop_reactor
             end
           end
-        end
-      end
 
-      context '#first_page' do
-        it 'calls the errback callback when first page headers are missing' do
-          run_reactor do
-            subject.next_page do |paginated_resource|
-              deferrable = subject.first_page
-              deferrable.errback do |error|
-                expect(error).to be_a(Ably::Exceptions::InvalidPageError)
+          it 'allows a success callback block to be added' do
+            run_reactor do
+              subject.next_page do |paginated_resource|
+                expect(paginated_resource).to be_a(Ably::Models::PaginatedResource)
                 stop_reactor
               end
             end
           end
         end
+
+        context '#first_page' do
+          it 'calls the errback callback when first page headers are missing' do
+            run_reactor do
+              subject.next_page do |paginated_resource|
+                deferrable = subject.first_page
+                deferrable.errback do |error|
+                  expect(error).to be_a(Ably::Exceptions::InvalidPageError)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
       end
     end
   end

data/spec/unit/models/presence_message_spec.rb

@@ -1,5 +1,6 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'support/model_helper'
+require 'shared/model_behaviour'
 
 describe Ably::Models::PresenceMessage do
   include Ably::Modules::Conversions
@@ -8,19 +9,87 @@ describe Ably::Models::PresenceMessage 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(client_id member_id data encoding) do
+  it_behaves_like 'a model', with_simple_attributes: %w(client_id data encoding) do
     let(:model_args) { [protocol_message] }
   end
 
+  context '#connection_id attribute' do
+    let(:protocol_connection_id) { random_str }
+    let(:protocol_message) { Ably::Models::ProtocolMessage.new('connectionId' => protocol_connection_id, action: 1, timestamp: protocol_message_timestamp) }
+    let(:model_connection_id) { random_str }
+
+    context 'when this model has a connectionId attribute' do
+      context 'but no protocol message' do
+        let(:model) { subject.new('connectionId' => model_connection_id ) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+
+      context 'with a protocol message with a different connectionId' do
+        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+    end
+
+    context 'when this model has no connectionId attribute' do
+      context 'and no protocol message' do
+        let(:model) { subject.new({ }) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to be_nil
+        end
+      end
+
+      context 'with a protocol message with a connectionId' do
+        let(:model) { subject.new({ }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(protocol_connection_id)
+        end
+      end
+    end
+  end
+
+  context '#member_key attribute' do
+    let(:model) { subject.new(client_id: 'client_id', connection_id: 'connection_id') }
+
+    it 'is string in format connection_id:client_id' do
+      expect(model.member_key).to eql('connection_id:client_id')
+    end
+
+    context 'with the same client id across multiple connections' do
+      let(:connection_1) { subject.new({ client_id: 'same', connection_id: 'unique' }, protocol_message) }
+      let(:connection_2) { subject.new({ client_id: 'same', connection_id: 'different' }, protocol_message) }
+
+      it 'is unique' do
+        expect(connection_1.member_key).to_not eql(connection_2.member_key)
+      end
+    end
+
+    context 'with a single connection and different client_ids' do
+      let(:client_1) { subject.new({ client_id: 'unique', connection_id: 'same' }, protocol_message) }
+      let(:client_2) { subject.new({ client_id: 'different', connection_id: 'same' }, protocol_message) }
+
+      it 'is unique' do
+        expect(client_1.member_key).to_not eql(client_2.member_key)
+      end
+    end
+  end
+
   context '#timestamp' do
     let(:model) { subject.new({}, protocol_message) }
-    it 'retrieves attribute :timestamp from ProtocolMessage' do
+    it 'retrieves attribute :timestamp as a Time object from ProtocolMessage' do
       expect(model.timestamp).to be_a(Time)
       expect(model.timestamp.to_i).to be_within(1).of(Time.now.to_i)
     end
   end
 
-  context 'Java naming' do
+  context 'Java naming', :api_private do
     let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
 
     it 'converts the attribute to ruby symbol naming convention' do
@@ -28,15 +97,25 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
-  context 'with action' do
-    let(:model) { subject.new({ action: 0 }, protocol_message) }
+  context 'with action', :api_private do
+    context 'absent' do
+      let(:model) { subject.new({ action: 0 }, protocol_message) }
+
+      it 'provides action as an Enum' do
+        expect(model.action).to eq(:absent)
+      end
+    end
+
+    context 'enter' do
+      let(:model) { subject.new({ action: 2 }, protocol_message) }
 
-    it 'provides action as an Enum' do
-      expect(model.action).to eq(:enter)
+      it 'provides action as an Enum' do
+        expect(model.action).to eq(:enter)
+      end
     end
   end
 
-  context 'without action' do
+  context 'without action', :api_private do
     let(:model) { subject.new({}, protocol_message) }
 
     it 'raises an exception when accessed' do
@@ -44,7 +123,71 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
-  context '#to_json' do
+  context 'initialized with' do
+    %w(client_id connection_id encoding).each do |attribute|
+      context ":#{attribute}" do
+        let(:encoded_value)   { value.encode(encoding) }
+        let(:value)           { random_str }
+        let(:options)         { { attribute.to_sym => encoded_value } }
+        let(:model)           { subject.new(options, protocol_message) }
+        let(:model_attribute) { model.public_send(attribute) }
+
+        context 'as UTF_8 string' do
+          let(:encoding) { Encoding::UTF_8 }
+
+          it 'is permitted' do
+            expect(model_attribute).to eql(encoded_value)
+          end
+
+          it 'remains as UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+        end
+
+        context 'as SHIFT_JIS string' do
+          let(:encoding) { Encoding::SHIFT_JIS }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as ASCII_8BIT string' do
+          let(:encoding) { Encoding::ASCII_8BIT }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as Integer' do
+          let(:encoded_value) { 1 }
+
+          it 'raises an argument error' do
+            expect { model_attribute }.to raise_error ArgumentError, /must be a String/
+          end
+        end
+
+        context 'as Nil' do
+          let(:encoded_value) { nil }
+
+          it 'is permitted' do
+            expect(model_attribute).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  context '#to_json', :api_private do
     let(:json_object) { JSON.parse(model.to_json) }
 
     context 'with valid data' do
@@ -64,7 +207,7 @@ describe Ably::Models::PresenceMessage do
     end
 
     context 'with binary data' do
-      let(:data) { MessagePack.pack(SecureRandom.hex(32)) }
+      let(:data) { MessagePack.pack(random_str(32)) }
       let(:model) { subject.new({ action: 'enter', data: data }, protocol_message) }
 
       it 'encodes as Base64 so that it can be converted to UTF-8 automatically by JSON#dump' do
@@ -77,8 +220,8 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
-  context 'from REST request with embedded fields' do
-    let(:id) { SecureRandom.hex }
+  context 'from REST request with embedded fields', :api_private do
+    let(:id) { random_str }
     let(:message_time) { Time.now + 60 }
     let(:timestamp) { as_since_epoch(message_time) }
     let(:model) { subject.new(id: id, timestamp: timestamp) }
@@ -104,19 +247,19 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
-  context 'part of ProtocolMessage' do
+  context 'part of ProtocolMessage', :api_private do
     let(:ably_time) { Time.now + 5 }
-    let(:message_serial) { SecureRandom.random_number(1_000_000) }
-    let(:connection_id) { SecureRandom.hex }
+    let(:message_serial) { random_int_str(1_000_000) }
+    let(:connection_id) { random_str }
 
-    let(:presence_0_payload) { SecureRandom.hex(8) }
+    let(:presence_0_payload) { random_str(8) }
     let(:presence_0_json) do
       {
         client_id: 'zero',
         data: presence_0_payload
       }
     end
-    let(:presence_1_payload) { SecureRandom.hex(8) }
+    let(:presence_1_payload) { random_str(8) }
     let(:presence_1_json) do
       {
         client_id: 'one',
@@ -124,7 +267,7 @@ describe Ably::Models::PresenceMessage do
       }
     end
 
-    let(:protocol_message_id) { SecureRandom.hex }
+    let(:protocol_message_id) { random_str }
     let(:protocol_message) do
       Ably::Models::ProtocolMessage.new({
         action: :message,
@@ -151,7 +294,7 @@ describe Ably::Models::PresenceMessage do
     end
   end
 
-  context 'PresenceMessage conversion method' do
+  context 'PresenceMessage conversion method', :api_private do
     let(:json) { { client_id: 'test' } }
 
     context 'with JSON' do