ably-rest 0.7.1 → 0.7.3

data/lib/submodules/ably-ruby/spec/unit/realtime/channel_spec.rb

@@ -0,0 +1,206 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/protocol_msgbus_behaviour'
+
+describe Ably::Realtime::Channel do
+  let(:client)       { double('client').as_null_object }
+  let(:channel_name) { 'test' }
+
+  subject do
+    Ably::Realtime::Channel.new(client, channel_name)
+  end
+
+  describe '#initializer' do
+    let(:channel_name) { random_str.encode(encoding) }
+
+    context 'as UTF_8 string' do
+      let(:encoding) { Encoding::UTF_8 }
+
+      it 'is permitted' do
+        expect(subject.name).to eql(channel_name)
+      end
+
+      it 'remains as UTF-8' do
+        expect(subject.name.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(subject.name.encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'is compatible with original encoding' do
+        expect(subject.name.encode(encoding)).to eql(channel_name)
+      end
+    end
+
+    context 'as ASCII_8BIT string' do
+      let(:encoding) { Encoding::ASCII_8BIT }
+
+      it 'gets converted to UTF-8' do
+        expect(subject.name.encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'is compatible with original encoding' do
+        expect(subject.name.encode(encoding)).to eql(channel_name)
+      end
+    end
+
+    context 'as Integer' do
+      let(:channel_name) { 1 }
+
+      it 'raises an argument error' do
+        expect { subject }.to raise_error ArgumentError, /must be a String/
+      end
+    end
+
+    context 'as Nil' do
+      let(:channel_name) { nil }
+
+      it 'raises an argument error' do
+        expect { subject }.to raise_error ArgumentError, /must be a String/
+      end
+    end
+  end
+
+  describe '#publish name argument' do
+    let(:encoded_value) { random_str.encode(encoding) }
+
+    before do
+      allow(subject).to receive(:create_message).and_return('message_stubbed')
+    end
+
+    context 'as UTF_8 string' do
+      let(:encoding) { Encoding::UTF_8 }
+
+      it 'is permitted' do
+        expect(subject.publish(encoded_value, 'data')).to eql('message_stubbed')
+      end
+    end
+
+    context 'as SHIFT_JIS string' do
+      let(:encoding) { Encoding::SHIFT_JIS }
+
+      it 'is permitted' do
+        expect(subject.publish(encoded_value, 'data')).to eql('message_stubbed')
+      end
+    end
+
+    context 'as ASCII_8BIT string' do
+      let(:encoding) { Encoding::ASCII_8BIT }
+
+      it 'is permitted' do
+        expect(subject.publish(encoded_value, 'data')).to eql('message_stubbed')
+      end
+    end
+
+    context 'as Integer' do
+      let(:encoded_value) { 1 }
+
+      it 'raises an argument error' do
+        expect { subject.publish(encoded_value, 'data') }.to raise_error ArgumentError, /must be a String/
+      end
+    end
+
+    context 'as Nil' do
+      let(:encoded_value) { nil }
+
+      it 'raises an argument error' do
+        expect { subject.publish(encoded_value, 'data') }.to raise_error ArgumentError, /must be a String/
+      end
+    end
+  end
+
+  describe 'callbacks' do
+    specify 'are supported for valid STATE events' do
+      state = nil
+      subject.on(:initialized) { state = :ready }
+      expect { subject.trigger(:initialized) }.to change { state }.to(:ready)
+    end
+
+    specify 'fail with unacceptable STATE event names' do
+      expect { subject.on(:invalid) }.to raise_error KeyError
+      expect { subject.trigger(:invalid) }.to raise_error KeyError
+      expect { subject.off(:invalid) }.to raise_error KeyError
+    end
+  end
+
+  context 'msgbus', :api_private do
+    let(:message) do
+      Ably::Models::Message.new({
+        'name' => 'test',
+        'data' => 'payload'
+      }, instance_double('Ably::Models::ProtocolMessage'))
+    end
+    let(:msgbus) { subject.__incoming_msgbus__ }
+
+    specify 'supports messages' do
+      received = 0
+      msgbus.subscribe(:message) { received += 1 }
+      expect { msgbus.publish(:message, message) }.to change { received }.to(1)
+    end
+
+    specify 'fail with unacceptable STATE event names' do
+      expect { msgbus.subscribe(:invalid) }.to raise_error KeyError
+      expect { msgbus.publish(:invalid) }.to raise_error KeyError
+      expect { msgbus.unsubscribe(:invalid) }.to raise_error KeyError
+    end
+  end
+
+  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, encode: nil, decode: nil) }
+
+    context '#subscribe' do
+      specify 'to all events' do
+        subject.subscribe { |message| message_history[:received] += 1}
+        subject.__incoming_msgbus__.publish(:message, message)
+        expect(message_history[:received]).to eql(1)
+      end
+
+      specify 'to specific events' do
+        subject.subscribe(event_name) { |message| message_history[:received] += 1 }
+        subject.subscribe('move')  { |message| message_history[:received] += 1 }
+        subject.__incoming_msgbus__.publish(:message, message)
+        expect(message_history[:received]).to eql(1)
+      end
+    end
+
+    context '#unsubscribe' do
+      let(:callback) do
+        Proc.new { |message| message_history[:received] += 1 }
+      end
+      before do
+        subject.subscribe(event_name, &callback)
+      end
+
+      specify 'to all events' do
+        subject.unsubscribe &callback
+        subject.__incoming_msgbus__.publish(:message, message)
+        expect(message_history[:received]).to eql(0)
+      end
+
+      specify 'to specific events' do
+        subject.unsubscribe event_name, &callback
+        subject.__incoming_msgbus__.publish(:message, message)
+        expect(message_history[:received]).to eql(0)
+      end
+
+      specify 'to specific non-matching events' do
+        subject.unsubscribe 'move', &callback
+        subject.__incoming_msgbus__.publish(:message, message)
+        expect(message_history[:received]).to eql(1)
+      end
+
+      specify 'all callbacks by not providing a callback' do
+        subject.unsubscribe event_name
+        subject.__incoming_msgbus__.publish(:message, message)
+        expect(message_history[:received]).to eql(0)
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/realtime/channels_spec.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Realtime::Channels do
+  let(:connection) { instance_double('Ably::Realtime::Connection', on: true) }
+  let(:client) { instance_double('Ably::Realtime::Client', connection: connection) }
+  let(:channel_name) { 'unique' }
+  let(:options) { { 'bizarre' => 'value' } }
+
+  subject { Ably::Realtime::Channels.new(client) }
+
+  context 'creating channels' do
+    it '#get creates a channel' do
+      expect(Ably::Realtime::Channel).to receive(:new).with(client, channel_name, options)
+      subject.get(channel_name, options)
+    end
+
+    it '#get will reuse the channel object' 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)
+    end
+
+    it '[] creates a channel' do
+      expect(Ably::Realtime::Channel).to receive(:new).with(client, channel_name, options)
+      subject.get(channel_name, options)
+    end
+  end
+
+  context '#fetch' do
+    it 'retrieves a channel if it exists' do
+      channel = subject.get(channel_name, options)
+      expect(subject.fetch(channel_name)).to eql(channel)
+    end
+
+    it 'calls the block if channel is missing' do
+      block_called = false
+      subject.fetch(channel_name) { block_called = true }
+      expect(block_called).to eql(true)
+    end
+  end
+
+  context 'destroying channels' do
+    it '#release detatches and then releases the channel resoures' do
+      released_channel = subject.get(channel_name, options)
+      expect(released_channel).to receive(:detach).and_yield
+      subject.release(channel_name)
+      expect(subject.get(channel_name, options).object_id).to_not eql(released_channel.object_id)
+    end
+  end
+
+  context 'is Enumerable' do
+    let(:channel_count) { 5 }
+    let(:mock_channel)  { instance_double('Ably::Realtime::Channel') }
+
+    before do
+      allow(Ably::Realtime::Channel).to receive(:new).and_return(mock_channel)
+      channel_count.times { |index| subject.get("channel-#{index}") }
+    end
+
+    it 'allows enumeration' do
+      expect(subject.map.count).to eql(channel_count)
+    end
+
+    context '#each' do
+      it 'returns an enumerator' do
+        expect(subject.each).to be_a(Enumerator)
+      end
+
+      it 'yields each channel' do
+        subject.each do |channel|
+          expect(channel).to eql(mock_channel)
+        end
+      end
+    end
+
+    it 'provides #length' do
+      expect(subject.length).to eql(channel_count)
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/realtime/client_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/client_initializer_behaviour'
+
+describe Ably::Realtime::Client do
+  subject do
+    Ably::Realtime::Client.new(client_options)
+  end
+
+  it_behaves_like 'a client initializer'
+
+  context 'delegation to the REST Client' do
+    let(:client_options) { { api_key: 'appid.keyuid:keysecret' } }
+
+    it 'passes on the options to the initializer' do
+      rest_client = instance_double('Ably::Rest::Client', auth: instance_double('Ably::Auth'), options: client_options)
+      expect(Ably::Rest::Client).to receive(:new).with(client_options).and_return(rest_client)
+      subject
+    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
+        end
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/realtime/connection_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'shared/protocol_msgbus_behaviour'
+
+describe Ably::Realtime::Connection do
+  let(:client) { instance_double('Ably::Realtime::Client', logger: double('logger').as_null_object) }
+
+  subject do
+    Ably::Realtime::Connection.new(client)
+  end
+
+  before do
+    expect(EventMachine).to receive(:next_tick)  # non_blocking_loop_while for delivery of messages async
+    subject.__incoming_protocol_msgbus__.off
+    subject.__outgoing_protocol_msgbus__.off
+  end
+
+  describe 'callbacks' do
+    specify 'are supported for valid STATE events' do
+      state = nil
+      subject.on(:initialized) { state = :ready }
+      expect { subject.trigger(:initialized) }.to change { state }.to(:ready)
+    end
+
+    specify 'fail with unacceptable STATE event names' do
+      expect { subject.on(:invalid) }.to raise_error KeyError
+      expect { subject.trigger(:invalid) }.to raise_error KeyError
+      expect { subject.off(:invalid) }.to raise_error KeyError
+    end
+  end
+
+  it_behaves_like 'an incoming protocol message bus'
+  it_behaves_like 'an outgoing protocol message bus'
+end

data/lib/submodules/ably-ruby/spec/unit/realtime/incoming_message_dispatcher_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Ably::Realtime::Client::IncomingMessageDispatcher, :api_private do
+  let(:msgbus) do
+    Ably::Util::PubSub.new
+  end
+  let(:connection) do
+    instance_double('Ably::Realtime::Connection', __incoming_protocol_msgbus__: msgbus, configure_new: true, id: nil)
+  end
+  let(:client) do
+    instance_double('Ably::Realtime::Client', channels: {})
+  end
+
+  subject { Ably::Realtime::Client::IncomingMessageDispatcher.new(client, connection) }
+
+  context '#initialize' do
+    it 'should subscribe to protocol messages from the connection' do
+      expect(msgbus).to receive(:subscribe).with(:protocol_message).and_call_original
+      subject
+    end
+  end
+
+  context '#dispatch_protocol_message' do
+    before { subject }
+
+    it 'should raise an exception if a message is sent that is not a ProtocolMessage' do
+      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 :protocol_message, Ably::Models::ProtocolMessage.new(:action => :attached, channel: 'unknown')
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/realtime/presence_spec.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/protocol_msgbus_behaviour'
+
+describe Ably::Realtime::Presence do
+  let(:channel) { double('Ably::Realtime::Channel').as_null_object }
+
+  subject do
+    Ably::Realtime::Presence.new(channel)
+  end
+
+  describe 'callbacks' do
+    specify 'are supported for valid STATE events' do
+      state = nil
+      subject.on(:initialized) { state = :entered }
+      expect { subject.trigger(:initialized) }.to change { state }.to(:entered)
+    end
+
+    specify 'fail with unacceptable STATE event names' do
+      expect { subject.on(:invalid) }.to raise_error KeyError
+      expect { subject.trigger(:invalid) }.to raise_error KeyError
+      expect { subject.off(:invalid) }.to raise_error KeyError
+    end
+  end
+
+  context 'msgbus', :api_private do
+    let(:message) do
+      Ably::Models::PresenceMessage.new({
+        'action' => 0,
+        'connection_id' => random_str,
+      }, instance_double('Ably::Models::ProtocolMessage'))
+    end
+    let(:msgbus) { subject.__incoming_msgbus__ }
+
+    specify 'supports messages' do
+      received = 0
+      msgbus.subscribe(:presence) { received += 1 }
+      expect { msgbus.publish(:presence, message) }.to change { received }.to(1)
+    end
+
+    specify 'fail with unacceptable STATE event names' do
+      expect { msgbus.subscribe(:invalid) }.to raise_error KeyError
+      expect { msgbus.publish(:invalid) }.to raise_error KeyError
+      expect { msgbus.unsubscribe(:invalid) }.to raise_error KeyError
+    end
+  end
+
+  context 'subscriptions' do
+    let(:message_history) { Hash.new { |hash, key| hash[key] = 0 } }
+    let(:presence_action) { Ably::Models::PresenceMessage::ACTION.Enter }
+    let(:message) do
+      instance_double('Ably::Models::PresenceMessage', action: presence_action, connection_id: random_str, decode: true, member_key: random_str)
+    end
+
+    context '#subscribe' do
+      before do
+        subject.sync_completed
+      end
+
+      specify 'to all presence state actions' do
+        subject.subscribe { |message| message_history[:received] += 1}
+        subject.__incoming_msgbus__.publish(:presence, message)
+        expect(message_history[:received]).to eql(1)
+      end
+
+      specify 'to specific presence state actions' do
+        subject.subscribe(presence_action) { |message| message_history[:received] += 1 }
+        subject.subscribe(:leave)  { |message| message_history[:received] += 1 }
+        subject.__incoming_msgbus__.publish(:presence, message)
+        expect(message_history[:received]).to eql(1)
+      end
+    end
+
+    context '#unsubscribe' do
+      before do
+        subject.sync_completed
+      end
+
+      let(:callback) do
+        Proc.new { |message| message_history[:received] += 1 }
+      end
+      before do
+        subject.subscribe(presence_action, &callback)
+      end
+
+      specify 'to all presence state actions' do
+        subject.unsubscribe &callback
+        subject.__incoming_msgbus__.publish(:presence, message)
+        expect(message_history[:received]).to eql(0)
+      end
+
+      specify 'to specific presence state actions' do
+        subject.unsubscribe presence_action, &callback
+        subject.__incoming_msgbus__.publish(:presence, message)
+        expect(message_history[:received]).to eql(0)
+      end
+
+      specify 'to specific non-matching presence state actions' do
+        subject.unsubscribe :leave, &callback
+        subject.__incoming_msgbus__.publish(:presence, message)
+        expect(message_history[:received]).to eql(1)
+      end
+
+      specify 'all callbacks by not providing a callback' do
+        subject.unsubscribe presence_action
+        subject.__incoming_msgbus__.publish(:presence, message)
+        expect(message_history[:received]).to eql(0)
+      end
+    end
+  end
+end