ably 0.1.6 → 0.2.0

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

@@ -0,0 +1,100 @@
+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(:client)              { instance_double('Ably::Realtime::Client') }
+
+  subject { Ably::Models::MessageEncoders::Utf8.new(client) }
+
+  context '#decode' do
+    before do
+      subject.decode message, {}
+    end
+
+    context 'message with utf8 payload' do
+      let(:message) { { data: string_ascii, encoding: 'utf-8' } }
+
+      it 'sets the encoding' do
+        expect(message[:data]).to eq(string_utf8)
+        expect(message[:data].encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'strips the encoding' do
+        expect(message[:encoding]).to be_nil
+      end
+    end
+
+    context 'message with utf8 payload before other payloads' do
+      let(:message) { { data: string_utf8, encoding: 'json/utf-8' } }
+
+      it 'sets the encoding' do
+        expect(message[:data]).to eql(string_utf8)
+        expect(message[:data].encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'strips the encoding' do
+        expect(message[:encoding]).to eql('json')
+      end
+    end
+
+    context 'message with another payload' do
+      let(:message) { { data: string_ascii, encoding: 'json' } }
+
+      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('json')
+      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,7 @@
 require 'spec_helper'
 require 'support/model_helper'
+require 'base64'
+require 'msgpack'
 
 describe Ably::Models::Message do
   include Ably::Modules::Conversions
@@ -8,7 +10,7 @@ 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(name client_id data) do
+  it_behaves_like 'a model', with_simple_attributes: %w(name client_id data encoding) do
     let(:model_args) { [protocol_message] }
   end
 
@@ -46,6 +48,19 @@ describe Ably::Models::Message do
         expect { model.to_json }.to raise_error RuntimeError, /cannot generate a valid Hash/
       end
     end
+
+    context 'with binary data' do
+      let(:data) { MessagePack.pack(SecureRandom.hex(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
+        expect(json_object["data"]).to eql(::Base64.encode64(data))
+      end
+
+      it 'adds Base64 encoding' do
+        expect(json_object["encoding"]).to eql('base64')
+      end
+    end
   end
 
   context 'from REST request with embedded fields' do

data/spec/unit/models/paginated_resource_spec.rb

@@ -67,6 +67,52 @@ describe Ably::Models::PaginatedResource do
     end
   end
 
+  context 'with each block' do
+    let(:headers) do
+      {
+        'link' => [
+          '<./history?index=1>; rel="next"'
+        ].join(', ')
+      }
+    end
+    let(:paged_client) do
+      instance_double('Ably::Rest::Client').tap do |client|
+        allow(client).to receive(:get).and_return(http_response_page2)
+      end
+    end
+    let(:body_page2) do
+      [
+        { id: 2 },
+        { id: 3 }
+      ]
+    end
+    let(:http_response_page2) do
+      instance_double('Faraday::Response', {
+        body: body_page2,
+        headers: headers
+      })
+    end
+
+    subject do
+      paginated_resource_class.new(http_response, full_url, paged_client, paginated_resource_options) do |resource|
+        resource[:added_attribute_from_block] = "id:#{resource[:id]}"
+        resource
+      end
+    end
+
+    it 'calls the block for each resource after retrieving the resources' do
+      expect(subject[0][:added_attribute_from_block]).to eql("id:#{body[0][:id]}")
+    end
+
+    it 'calls the block for each resource on second page after retrieving the resources' do
+      page_1_first_id = subject[0][:id]
+      next_page = subject.next_page
+
+      expect(next_page[0][:added_attribute_from_block]).to eql("id:#{body_page2[0][:id]}")
+      expect(next_page[0][:id]).to_not eql(page_1_first_id)
+    end
+  end
+
   context 'with non paged http response' do
     it 'is the first page' do
       expect(subject).to be_first_page

data/spec/unit/models/presence_message_spec.rb

@@ -8,7 +8,7 @@ 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 client_data) do
+  it_behaves_like 'a model', with_simple_attributes: %w(client_id member_id data encoding) do
     let(:model_args) { [protocol_message] }
   end
 
@@ -62,6 +62,19 @@ describe Ably::Models::PresenceMessage do
         expect { model.to_json }.to raise_error KeyError, /cannot generate a valid Hash/
       end
     end
+
+    context 'with binary data' do
+      let(:data) { MessagePack.pack(SecureRandom.hex(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
+        expect(json_object["data"]).to eql(::Base64.encode64(data))
+      end
+
+      it 'adds Base64 encoding' do
+        expect(json_object["encoding"]).to eql('base64')
+      end
+    end
   end
 
   context 'from REST request with embedded fields' do
@@ -100,14 +113,14 @@ describe Ably::Models::PresenceMessage do
     let(:presence_0_json) do
       {
         client_id: 'zero',
-        client_data: presence_0_payload
+        data: presence_0_payload
       }
     end
     let(:presence_1_payload) { SecureRandom.hex(8) }
     let(:presence_1_json) do
       {
         client_id: 'one',
-        client_data: presence_1_payload
+        data: presence_1_payload
       }
     end
 
@@ -133,8 +146,8 @@ describe Ably::Models::PresenceMessage do
     end
 
     it 'should not modify the data payload' do
-      expect(presence_0.client_data).to eql(presence_0_payload)
-      expect(presence_1.client_data).to eql(presence_1_payload)
+      expect(presence_0.data).to eql(presence_0_payload)
+      expect(presence_1.data).to eql(presence_1_payload)
     end
   end
 

data/spec/unit/models/token_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Ably::Models::Token do
   subject { Ably::Models::Token }

data/spec/unit/modules/event_emitter_spec.rb

@@ -95,19 +95,33 @@ describe Ably::Modules::EventEmitter do
       subject.trigger :message, msg
     end
 
-    it 'deletes matching callbacks' do
-      expect(obj).to_not receive(:received_message).with(msg)
-      subject.off(:message, &callback)
-    end
+    context 'with event names as arguments' do
+      it 'deletes matching callbacks' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off(:message, &callback)
+      end
+
+      it 'deletes all callbacks if not block given' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off(:message)
+      end
 
-    it 'deletes all callbacks if not block given' do
-      expect(obj).to_not receive(:received_message).with(msg)
-      subject.off(:message)
+      it 'continues if the block does not exist' do
+        expect(obj).to receive(:received_message).with(msg)
+        subject.off(:message) { true }
+      end
     end
 
-    it 'continues if the block does not exist' do
-      expect(obj).to receive(:received_message).with(msg)
-      subject.off(:message) { true }
+    context 'without any event names' do
+      it 'deletes all matching callbacks' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off(&callback)
+      end
+
+      it 'deletes all callbacks if not block given' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.off
+      end
     end
   end
 end

data/spec/unit/realtime/channel_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require "support/protocol_msgbus_helper"
+require 'support/protocol_msgbus_helper'
 
 describe Ably::Realtime::Channel do
-  let(:client) { double('client').as_null_object }
+  let(:client)       { double('client').as_null_object }
   let(:channel_name) { 'test' }
 
   subject do
@@ -48,7 +48,7 @@ describe Ably::Realtime::Channel do
   context 'subscriptions' do
     let(:message_history) { Hash.new { |hash, key| hash[key] = 0 } }
     let(:event_name) { 'click' }
-    let(:message) { instance_double('Ably::Models::Message', name: event_name) }
+    let(:message) { instance_double('Ably::Models::Message', name: event_name, encode: nil, decode: nil) }
 
     context '#subscribe' do
       specify 'to all events' do

data/spec/unit/realtime/channels_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Ably::Realtime::Channels do
   let(:connection) { instance_double('Ably::Realtime::Connection', on: true) }

data/spec/unit/realtime/client_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require "support/protocol_msgbus_helper"
+require 'support/protocol_msgbus_helper'
 
 describe Ably::Realtime::Client do
   let(:client_options) { 'appid.keyuid:keysecret' }
@@ -27,12 +27,54 @@ describe Ably::Realtime::Client do
     end
 
     context 'for attribute' do
-      [:environment, :use_tls?, :logger, :log_level].each do |attribute|
+      [:environment, :use_tls?, :log_level].each do |attribute|
         specify "##{attribute}" do
           expect(subject.rest_client).to receive(attribute)
           subject.public_send attribute
         end
       end
     end
+
+    context 'logger' do
+      context 'defaults' do
+        let(:logger) { subject.logger }
+
+        subject { Ably::Realtime::Client.new(client_options) }
+
+        it 'uses default Ruby Logger by default' do
+          expect(subject.logger.logger).to be_a(::Logger)
+        end
+
+        it 'defaults to Logger::ERROR log level' do
+          expect(subject.logger.log_level).to eql(::Logger::ERROR)
+        end
+
+        it 'returns the connection ID' do
+          allow(subject).to receive_message_chain(:connection, :id).and_return('AAA')
+          expect(logger.logger.formatter.call(0, Time.now, '', 'unique_message')).to match(/AAA/)
+        end
+      end
+
+      context 'with custom logger and log_level' do
+        let(:custom_logger) do
+          Class.new do
+            extend Forwardable
+            def initialize
+              @logger = Logger.new(STDOUT)
+            end
+            def_delegators :@logger, :fatal, :error, :warn, :info, :debug, :level, :level=
+          end
+        end
+        subject { Ably::Realtime::Client.new(api_key: 'appid.keyuid:keysecret', logger: custom_logger.new, log_level: :debug) }
+
+        it 'uses the custom logger' do
+          expect(subject.logger.logger.class).to eql(custom_logger)
+        end
+
+        it 'sets the custom log level' do
+          expect(subject.logger.log_level).to eql(Logger::DEBUG)
+        end
+      end
+    end
   end
 end

data/spec/unit/realtime/connection_spec.rb

@@ -10,8 +10,8 @@ describe Ably::Realtime::Connection do
   end
 
   before do
-    expect(EventMachine::Timer).to receive(:new)
-    expect(EventMachine).to receive(:next_tick)
+    expect(EventMachine::Timer).to receive(:new) # Connection Manager #initializer
+    expect(EventMachine).to receive(:next_tick)  # non_blocking_loop_while for delivery of messages async
   end
 
   describe 'callbacks' do

data/spec/unit/realtime/incoming_message_dispatcher_spec.rb

@@ -5,7 +5,7 @@ describe Ably::Realtime::Client::IncomingMessageDispatcher do
     Ably::Util::PubSub.new
   end
   let(:connection) do
-    instance_double('Ably::Realtime::Connection', __incoming_protocol_msgbus__: msgbus, update_connection_id: true)
+    instance_double('Ably::Realtime::Connection', __incoming_protocol_msgbus__: msgbus, update_connection_id: true, id: nil)
   end
   let(:client) do
     instance_double('Ably::Realtime::Client', channels: {})
@@ -15,7 +15,7 @@ describe Ably::Realtime::Client::IncomingMessageDispatcher do
 
   context '#initialize' do
     it 'should subscribe to protocol messages from the connection' do
-      expect(msgbus).to receive(:subscribe).with(:message).and_call_original
+      expect(msgbus).to receive(:subscribe).with(:protocol_message).and_call_original
       subject
     end
   end
@@ -24,13 +24,13 @@ describe Ably::Realtime::Client::IncomingMessageDispatcher do
     before { subject }
 
     it 'should raise an exception if a message is sent that is not a ProtocolMessage' do
-      expect { msgbus.publish :message, nil }.to raise_error ArgumentError
+      expect { msgbus.publish :protocol_message, nil }.to raise_error ArgumentError
     end
 
     it 'should warn if a message is received for a non-existent channel' do
       allow(subject).to receive_message_chain(:logger, :debug)
       expect(subject).to receive_message_chain(:logger, :warn)
-      msgbus.publish :message, Ably::Models::ProtocolMessage.new(:action => :attached, channel: 'unknown')
+      msgbus.publish :protocol_message, Ably::Models::ProtocolMessage.new(:action => :attached, channel: 'unknown')
     end
   end
 end

data/spec/unit/realtime/presence_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require "support/protocol_msgbus_helper"
+require 'support/protocol_msgbus_helper'
 
 describe Ably::Realtime::Presence do
   let(:channel) { double('Ably::Realtime::Channel').as_null_object }

data/spec/unit/realtime/realtime_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Ably::Realtime do
   let(:options) { { api_key: 'app.key:secret' } }
@@ -8,8 +8,8 @@ describe Ably::Realtime do
   end
 
   describe Ably::Realtime::Client do
-    describe "initializing the client" do
-      it "should disallow an invalid key" do
+    describe 'initializing the client' do
+      it 'should disallow an invalid key' do
         expect { Ably::Realtime::Client.new({}) }.to raise_error(ArgumentError, /api_key is missing/)
         expect { Ably::Realtime::Client.new(api_key: 'invalid') }.to raise_error(ArgumentError, /api_key is invalid/)
         expect { Ably::Realtime::Client.new(api_key: 'invalid:asdad') }.to raise_error(ArgumentError, /api_key is invalid/)