ably 0.6.2 → 0.7.0

data/spec/unit/realtime/channel_spec.rb

@@ -1,5 +1,6 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'support/protocol_msgbus_helper'
+require 'shared/protocol_msgbus_behaviour'
 
 describe Ably::Realtime::Channel do
   let(:client)       { double('client').as_null_object }
@@ -9,6 +10,110 @@ describe Ably::Realtime::Channel 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
@@ -23,7 +128,7 @@ describe Ably::Realtime::Channel do
     end
   end
 
-  context 'msgbus' do
+  context 'msgbus', :api_private do
     let(:message) do
       Ably::Models::Message.new({
         'name' => 'test',

data/spec/unit/realtime/channels_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe Ably::Realtime::Channels do

data/spec/unit/realtime/client_spec.rb

@@ -1,70 +1,30 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'support/protocol_msgbus_helper'
+require 'shared/client_initializer_behaviour'
 
 describe Ably::Realtime::Client do
-  let(:client_options) { 'appid.keyuid:keysecret' }
   subject do
     Ably::Realtime::Client.new(client_options)
   end
 
-  context 'delegation to the Rest Client' do
-    let(:options) { { arbitrary: 'value' } }
+  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: {})
+      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].each do |attribute|
+      [: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
-
-    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

@@ -1,6 +1,5 @@
 require 'spec_helper'
-require 'support/protocol_msgbus_helper'
-require 'support/event_machine_helper'
+require 'shared/protocol_msgbus_behaviour'
 
 describe Ably::Realtime::Connection do
   let(:client) { instance_double('Ably::Realtime::Client', logger: double('logger').as_null_object) }
@@ -10,8 +9,9 @@ describe Ably::Realtime::Connection do
   end
 
   before do
-    expect(EventMachine::Timer).to receive(:new) # Connection Manager #initializer
     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

data/spec/unit/realtime/incoming_message_dispatcher_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Ably::Realtime::Client::IncomingMessageDispatcher do
+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, update_connection_id: true, id: nil)
+    instance_double('Ably::Realtime::Connection', __incoming_protocol_msgbus__: msgbus, update_connection_id_and_key: true, id: nil)
   end
   let(:client) do
     instance_double('Ably::Realtime::Client', channels: {})

data/spec/unit/realtime/presence_spec.rb

@@ -1,5 +1,6 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'support/protocol_msgbus_helper'
+require 'shared/protocol_msgbus_behaviour'
 
 describe Ably::Realtime::Presence do
   let(:channel) { double('Ably::Realtime::Channel').as_null_object }
@@ -22,11 +23,11 @@ describe Ably::Realtime::Presence do
     end
   end
 
-  context 'msgbus' do
+  context 'msgbus', :api_private do
     let(:message) do
       Ably::Models::PresenceMessage.new({
         'action' => 0,
-        'member_id' => SecureRandom.hex,
+        'connection_id' => random_str,
       }, instance_double('Ably::Models::ProtocolMessage'))
     end
     let(:msgbus) { subject.__incoming_msgbus__ }
@@ -48,10 +49,14 @@ describe Ably::Realtime::Presence 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, member_id: SecureRandom.hex, decode: true)
+      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)
@@ -67,6 +72,10 @@ describe Ably::Realtime::Presence do
     end
 
     context '#unsubscribe' do
+      before do
+        subject.sync_completed
+      end
+
       let(:callback) do
         Proc.new { |message| message_history[:received] += 1 }
       end

data/spec/unit/realtime/realtime_spec.rb

@@ -6,15 +6,4 @@ describe Ably::Realtime do
   specify 'constructor returns an Ably::Realtime::Client' do
     expect(Ably::Realtime.new(options)).to be_instance_of(Ably::Realtime::Client)
   end
-
-  describe Ably::Realtime::Client 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/)
-        expect { Ably::Realtime::Client.new(api_key: 'appid.keyuid:keysecret') }.to_not raise_error
-      end
-    end
-  end
 end

data/spec/unit/realtime/websocket_transport_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'support/protocol_msgbus_helper'
+require 'shared/protocol_msgbus_behaviour'
 
-describe Ably::Realtime::Connection::WebsocketTransport do
+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/' }

data/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/spec/unit/rest/channels_spec.rb

@@ -1,9 +1,10 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe Ably::Rest::Channels do
-  let(:client) { instance_double('Ably::Rest::Client') }
-  let(:channel_name) { 'unique' }
-  let(:options) { { 'bizarre' => 'value' } }
+  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) }
 

data/spec/unit/rest/client_spec.rb

@@ -1,145 +1,50 @@
+# encoding: utf-8
 require 'spec_helper'
+require 'shared/client_initializer_behaviour'
 
-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)
+describe Ably::Rest::Client do
+  subject do
+    Ably::Rest::Client.new(client_options)
   end
 
-  describe Ably::Rest::Client do
-    describe 'initializing the client' do
-      it 'should disallow an invalid key' do
-        expect { Ably::Rest::Client.new({}) }.to raise_error(ArgumentError, /api_key is missing/)
-        expect { Ably::Rest::Client.new(api_key: 'invalid') }.to raise_error(ArgumentError, /api_key is invalid/)
-        expect { Ably::Rest::Client.new(api_key: 'invalid:asdad') }.to raise_error(ArgumentError, /api_key is invalid/)
-        expect { Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret') }.to_not raise_error
-      end
-
-      it 'should disallow api_key and key_id' do
-        expect { Ably::Rest::Client.new(api_key: 'valid', key_id: 'invalid') }.to raise_error(ArgumentError, /api_key and key_id or key_secret are mutually exclusive/)
-      end
-
-      it 'should disallow api_key and key_secret' do
-        expect { Ably::Rest::Client.new(api_key: 'valid', key_secret: 'invalid') }.to raise_error(ArgumentError, /api_key and key_id or key_secret are mutually exclusive/)
-      end
-
-      context 'using key_id and key_secret' do
-        let(:client) { Ably::Rest::Client.new(key_id: 'id', key_secret: 'secret') }
-
-        it 'should allow key_id and key_secret in place of api_key' do
-          expect(client.auth.api_key).to eql('id:secret')
-        end
-      end
-
-      context 'with a string key instead of options' do
-        let(:options) { 'app.key:secret' }
-        subject { Ably::Rest::Client.new(options) }
-
-        it 'should set the api_key' do
-          expect(subject.auth.api_key).to eql(options)
-        end
-
-        it 'should set the key_id' do
-          expect(subject.auth.key_id).to eql('app.key')
-        end
-
-        it 'should set the key_secret' do
-          expect(subject.auth.key_secret).to eql('secret')
-        end
-      end
-
-      context 'with a client_id' do
-        it "should require a valid key" do
-          expect { Ably::Rest::Client.new(client_id: 'valid') }.to raise_error(ArgumentError, /client_id cannot be provided without a complete API key/)
-        end
-      end
-
-      it 'should default to the production REST end point' do
-        expect(Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret').endpoint.to_s).to eql('https://rest.ably.io')
-      end
-
-      it 'should allow an environment to be set' do
-        expect(Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret', environment: 'sandbox').endpoint.to_s).to eql('https://sandbox-rest.ably.io')
-      end
-
-      context 'with TLS disabled' do
-        let(:client) { Ably::Rest::Client.new(api_key: 'appid.keyid:secret', tls: false) }
-
-        it 'uses plain text' do
-          expect(client.use_tls?).to eql(false)
-        end
-
-        it 'uses HTTP' do
-          expect(client.endpoint.to_s).to eql('http://rest.ably.io')
-        end
-
-        it 'fails when authenticating with basic auth' do
-          expect { client.channel('a').publish('event', 'message') }.to raise_error(Ably::Exceptions::InsecureRequestError)
-        end
-      end
-
-      context 'with no TLS option provided' do
-        let(:client) { Ably::Rest::Client.new(api_key: 'appid.keyid:secret') }
-
-        it 'defaults to TLS' do
-          expect(client.use_tls?).to eql(true)
-        end
-      end
+  it_behaves_like 'a client initializer'
 
-      context 'with alternative environment' do
-        let(:client) { Ably::Rest::Client.new(api_key: 'appid.keyid:secret', environment: 'sandbox') }
+  context 'initializer options' do
+    context 'TLS' do
+      context 'disabled' do
+        let(:client_options) { { api_key: 'appid.keyuid:keysecret', tls: false } }
 
-        it 'should alter the endpoint' do
-          expect(client.endpoint.to_s).to eql('https://sandbox-rest.ably.io')
+        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 'delegators' do
-        subject { Ably::Rest::Client.new(options) }
-
-        it 'should delegate :client_id to .auth' do
-          expect(subject.auth).to receive(:client_id).and_return('john')
-          expect(subject.client_id).to eql('john')
-        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 'should delegate :auth_options to .auth' do
-          expect(subject.auth).to receive(:auth_options).and_return({ option: 1 })
-          expect(subject.auth_options).to eql({ option: 1 })
+          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 'logger' do
-        context 'defaults' do
-          subject { Ably::Rest::Client.new(options) }
+        context 'without an api_key' do
+          let(:client_options) { { use_token_auth: false } }
 
-          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)
+          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 '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::Rest::Client.new(options.merge(logger: custom_logger.new, log_level: :debug)) }
-
-          it 'uses the custom logger' do
-            expect(subject.logger.logger.class).to eql(custom_logger)
-          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 'sets the custom log level' do
-            expect(subject.logger.log_level).to eql(Logger::DEBUG)
+          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