ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Ably::Realtime do
+  let(:options) { { api_key: 'app.key:secret' } }
+
+  specify 'constructor returns an Ably::Realtime::Client' do
+    expect(Ably::Realtime.new(options)).to be_instance_of(Ably::Realtime::Client)
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'shared/protocol_msgbus_behaviour'
+
+describe Ably::Realtime::Connection::WebsocketTransport, :api_private do
+  let(:client_ignored) { double('Ably::Realtime::Client').as_null_object }
+  let(:connection)     { instance_double('Ably::Realtime::Connection', client: client_ignored, id: nil) }
+  let(:url)            { 'http://ably.io/' }
+
+  let(:websocket_transport_without_eventmachine) do
+    Ably::Realtime::Connection::WebsocketTransport.send(:allocate).tap do |websocket_transport|
+      websocket_transport.send(:initialize, connection, url)
+    end
+  end
+
+  before do
+    allow(Ably::Realtime::Connection::WebsocketTransport).to receive(:new).with(connection).and_return(websocket_transport_without_eventmachine)
+  end
+
+  subject do
+    Ably::Realtime::Connection::WebsocketTransport.new(connection)
+  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/rest/channel_spec.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Channels do
+  let(:client)       { instance_double('Ably::Rest::Client', encoders: [], post: instance_double('Faraday::Response', status: 201)) }
+  let(:channel_name) { 'unique' }
+
+  subject { Ably::Rest::Channel.new(client, channel_name) }
+
+  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) }
+
+    context 'as UTF_8 string' do
+      let(:encoding) { Encoding::UTF_8 }
+
+      it 'is permitted' do
+        expect(subject.publish(encoded_value, 'data')).to eql(true)
+      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(true)
+      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(true)
+      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
+end

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Channels do
+  let(:client)       { instance_double('Ably::Rest::Client') }
+  let(:channel_name) { 'unique'.encode(Encoding::UTF_8) }
+  let(:options)      { { 'bizarre' => 'value' } }
+
+  subject { Ably::Rest::Channels.new(client) }
+
+  context 'creating channels' do
+    it '#get creates a channel' do
+      expect(Ably::Rest::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::Rest::Channel)
+      expect(subject.get(channel_name, options).object_id).to eql(channel.object_id)
+    end
+
+    it '[] creates a channel' do
+      expect(Ably::Rest::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 releases the channel resoures' do
+      released_channel = subject.get(channel_name, options)
+      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::Rest::Channel') }
+
+    before do
+      allow(Ably::Rest::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/rest/client_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/client_initializer_behaviour'
+
+describe Ably::Rest::Client do
+  subject do
+    Ably::Rest::Client.new(client_options)
+  end
+
+  it_behaves_like 'a client initializer'
+
+  context 'initializer options' do
+    context 'TLS' do
+      context 'disabled' do
+        let(:client_options) { { api_key: 'appid.keyuid:keysecret', tls: false } }
+
+        it 'fails for any operation with basic auth and attempting to send an API key over a non-secure connection' do
+          expect { subject.channel('a').publish('event', 'message') }.to raise_error(Ably::Exceptions::InsecureRequestError)
+        end
+      end
+    end
+
+    context ':use_token_auth' do
+      context 'set to false' do
+        context 'with an api_key with :tls => false' do
+          let(:client_options) { { use_token_auth: false, api_key: 'appid.keyuid:keysecret', tls: false } }
+
+          it 'fails for any operation with basic auth and attempting to send an API key over a non-secure connection' do
+            expect { subject.channel('a').publish('event', 'message') }.to raise_error(Ably::Exceptions::InsecureRequestError)
+          end
+        end
+
+        context 'without an api_key' do
+          let(:client_options) { { use_token_auth: false } }
+
+          it 'fails as an api_key is required if not using token auth' do
+            expect { subject.channel('a').publish('event', 'message') }.to raise_error(ArgumentError)
+          end
+        end
+      end
+
+      context 'set to true' do
+        context 'without an api_key or token_id' do
+          let(:client_options) { { use_token_auth: true, api_key: true } }
+
+          it 'fails as an api_key is required to issue tokens' do
+            expect { subject.channel('a').publish('event', 'message') }.to raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/rest/rest_spec.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest do
+  let(:options) { { api_key: 'app.key:secret' } }
+
+  specify 'constructor returns an Ably::Rest::Client' do
+    expect(Ably::Rest.new(options)).to be_instance_of(Ably::Rest::Client)
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/util/crypto_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'msgpack'
+
+describe Ably::Util::Crypto do
+  let(:seret_key)  { random_str }
+  let(:cipher_options) { { key: seret_key } }
+  subject { Ably::Util::Crypto.new(cipher_options) }
+
+  context 'defaults' do
+    let(:expected_defaults) do
+      {
+        algorithm: 'AES',
+        mode: 'CBC',
+        key_length: 128
+      }
+    end
+
+    specify 'match other client libraries' do
+      expect(Ably::Util::Crypto::DEFAULTS).to eql(expected_defaults)
+      expect(Ably::Util::Crypto::BLOCK_LENGTH).to eql(16)
+    end
+  end
+
+  context 'encrypts & decrypt' do
+    let(:string) { random_str }
+    let(:byte_array) { random_str.to_msgpack.unpack('C*') }
+
+    specify '#encrypt encrypts a string' do
+      encrypted = subject.encrypt(string)
+      expect(subject.decrypt(encrypted)).to eql(string)
+    end
+
+    specify '#decrypt decrypts a string' do
+      encrypted = subject.encrypt(string)
+      expect(subject.decrypt(encrypted)).to eql(string)
+    end
+  end
+
+  context 'encrypting an empty string' do
+    let(:empty_string) { '' }
+
+    it 'raises an ArgumentError' do
+      expect { subject.encrypt(empty_string) }.to raise_error ArgumentError, /data must not be empty/
+    end
+  end
+
+  context 'using shared client lib fixture data' do
+    let(:resources_root)      { File.expand_path('../../../resources', __FILE__) }
+    let(:encryption_data_128) { JSON.parse(File.read(File.join(resources_root, 'crypto-data-128.json'))) }
+    let(:encryption_data_256) { JSON.parse(File.read(File.join(resources_root, 'crypto-data-256.json'))) }
+
+    shared_examples 'an Ably encrypter and decrypter' do
+      let(:algorithm)      { data['algorithm'].upcase }
+      let(:mode)           { data['mode'].upcase }
+      let(:key_length)     { data['keylength'] }
+      let(:secret_key)     { Base64.decode64(data['key']) }
+      let(:iv)             { Base64.decode64(data['iv']) }
+
+      let(:cipher_options) { { key: secret_key, algorithm: algorithm, mode: mode, key_length: key_length } }
+
+      context 'text payload' do
+        let(:payload)        { data['items'].first['encoded']['data'] }
+        let(:encrypted)      { data['items'].first['encrypted']['data'] }
+
+        it 'encrypts exactly the same binary data as other client libraries' do
+          expect(subject.encrypt(payload, iv: iv)).to eql(Base64.decode64(encrypted))
+        end
+
+        it 'decrypts exactly the same binary data as other client libraries' do
+          expect(subject.decrypt(Base64.decode64(encrypted))).to eql(payload)
+        end
+      end
+    end
+
+    context 'with AES-128-CBC' do
+      let(:data) { encryption_data_128 }
+
+      it_behaves_like 'an Ably encrypter and decrypter'
+    end
+
+    context 'with AES-256-CBC' do
+      let(:data) { encryption_data_256 }
+
+      it_behaves_like 'an Ably encrypter and decrypter'
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/util/pub_sub_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Ably::Util::PubSub do
+  let(:options) { {} }
+  let(:obj) { double('example') }
+  let(:msg) { double('message') }
+
+  subject { Ably::Util::PubSub.new(options) }
+
+  context 'event fan out' do
+    specify '#publish allows publishing to more than on subscriber' do
+      expect(obj).to receive(:received_message).with(msg).twice
+      2.times do
+        subject.subscribe(:message) { |msg| obj.received_message msg }
+      end
+      subject.publish :message, msg
+    end
+
+    it '#publish sends only messages to #subscribe callbacks matching event names' do
+      expect(obj).to receive(:received_message).with(msg).once
+      subject.subscribe(:valid) { |msg| obj.received_message msg }
+      subject.publish :valid, msg
+      subject.publish :ignored, msg
+      subject.publish 'valid', msg
+    end
+
+    context 'with coercion', api_private: true do
+      let(:options) do
+        { coerce_into: Proc.new { |event| String(event) } }
+      end
+
+      it 'calls the provided proc to coerce the event name' do
+        expect(obj).to receive(:received_message).with(msg).once
+        subject.subscribe('valid') { |msg| obj.received_message msg }
+        subject.publish :valid, msg
+      end
+
+      context 'and two different configurations but sharing the same class' do
+        let!(:exception_pubsub) { Ably::Util::PubSub.new(coerce_into: Proc.new { raise KeyError }) }
+
+        it 'does not share state' do
+          expect(obj).to receive(:received_message).with(msg).once
+          subject.subscribe('valid') { |msg| obj.received_message msg }
+          subject.publish :valid, msg
+
+          expect { exception_pubsub.publish :fail }.to raise_error KeyError
+        end
+      end
+    end
+
+    context 'without coercion', api_private: true do
+      it 'only matches event names on type matches' do
+        expect(obj).to_not receive(:received_message).with(msg)
+        subject.subscribe('valid') { |msg| obj.received_message msg }
+        subject.publish :valid, msg
+      end
+    end
+  end
+
+  context '#unsubscribe' do
+    let(:callback) { Proc.new { |msg| obj.received_message msg } }
+
+    before do
+      subject.subscribe(:message, &callback)
+    end
+
+    after do
+      subject.publish :message, msg
+    end
+
+    it 'deletes matching callbacks' do
+      expect(obj).to_not receive(:received_message).with(msg)
+      subject.unsubscribe(:message, &callback)
+    end
+
+    it 'deletes all callbacks if not block given' do
+      expect(obj).to_not receive(:received_message).with(msg)
+      subject.unsubscribe(:message)
+    end
+
+    it 'continues if the block does not exist' do
+      expect(obj).to receive(:received_message).with(msg)
+      subject.unsubscribe(:message) { true }
+    end
+  end
+end