ably 0.6.2 → 0.7.0

data/spec/acceptance/rest/stats_spec.rb

@@ -1,55 +1,60 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'securerandom'
-
-describe 'Ably::Rest::Client Stats' do
-  [:json, :msgpack].each do |protocol|
-    context "over #{protocol}" do
-      describe 'fetching application stats' do
-        before(:context) do
-          reload_test_app
-        end
 
-        def number_of_channels()             3 end
-        def number_of_messages_per_channel() 5 end
+describe Ably::Rest::Client, '#stats' do
+  before(:context) do
+    WebMock.disable! # ensure previous test's WebMock does not have side effects
+    reload_test_app
+  end
 
-        before(:context) do
-          @context_client = Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+  before(:context) do
+    client = Ably::Rest::Client.new(api_key: api_key, environment: environment)
 
-          # Wait until the start of the next minute according to the service
-          # time because stats are created in 1 minute intervals
-          service_time    = @context_client.time
-          @interval_start = (service_time.to_i / 60 + 1) * 60
-          sleep_time      = @interval_start - Time.now.to_i
+    number_of_channels             = 3
+    number_of_messages_per_channel = 5
 
-          if sleep_time > 30
-            @interval_start -= 60 # there is enough time to generate the stats in this minute interval
-          elsif sleep_time > 0
-            sleep sleep_time
-          end
+    # Wait until the start of the next minute according to the service
+    # time because stats are created in 1 minute intervals
+    service_time   = client.time
+    stats_setup_at = (service_time.to_i / 60 + 1) * 60
+    sleep_time     = stats_setup_at - Time.now.to_i
 
-          number_of_channels.times do |i|
-            channel = @context_client.channel("stats-#{i}")
+    if sleep_time > 30
+      stats_setup_at -= 60 # there is enough time to generate the stats in this minute interval
+    elsif sleep_time > 0
+      sleep sleep_time
+    end
 
-            number_of_messages_per_channel.times do |j|
-              channel.publish("event-#{j}", "data-#{j}") || raise("Unable to publish message")
-            end
-          end
+    number_of_channels.times do |i|
+      channel = client.channel("stats-#{i}")
 
-          sleep(10)
-        end
+      number_of_messages_per_channel.times do |j|
+        channel.publish("event-#{j}", "data-#{j}") || raise("Unable to publish message")
+      end
+    end
+
+    # wait for stats to be persisted
+    sleep 10
+
+    @stats_setup_at = stats_setup_at
+    @messages_published_count = number_of_channels * number_of_messages_per_channel
+  end
 
-        [:minute, :hour, :day, :month].each do |interval|
-          context "by #{interval}" do
-            it 'should return all the stats for the application' do
-              stats = @context_client.stats(start: @interval_start * 1000, by: interval.to_s, direction: 'forwards')
+  vary_by_protocol do
+    describe 'fetching application stats' do
+      [:minute, :hour, :day, :month].each do |interval|
+        context "by #{interval}" do
+          let(:client) {  Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol) }
 
-              expect(stats.size).to eql(1)
+          it 'should return all the stats for the application' do
+            stats = client.stats(start: @stats_setup_at * 1000, by: interval.to_s, direction: 'forwards')
 
-              stat = stats.first
+            expect(stats.size).to eql(1)
+            stat = stats.first
 
-              expect(stat[:inbound][:all][:messages][:count]).to eql(number_of_channels * number_of_messages_per_channel)
-              expect(stat[:inbound][:rest][:messages][:count]).to eql(number_of_channels * number_of_messages_per_channel)
-            end
+            expect(@messages_published_count).to be_a(Numeric)
+            expect(stat[:inbound][:all][:messages][:count]).to eql(@messages_published_count)
+            expect(stat[:inbound][:rest][:messages][:count]).to eql(@messages_published_count)
           end
         end
       end

data/spec/acceptance/rest/time_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
-describe 'Ably::REST::Client time' do
-  [:msgpack, :json].each do |protocol|
-    context "over #{protocol}" do
-      let(:client) do
-        Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
-      end
+describe Ably::Rest::Client, '#time' do
+  vary_by_protocol do
+    let(:client) do
+      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+    end
 
-      describe 'fetching the service time' do
-        it 'should return the service time as a Time object' do
-          expect(client.time).to be_within(2).of(Time.now)
-        end
+    describe 'fetching the service time' do
+      it 'should return the service time as a Time object' do
+        expect(client.time).to be_within(2).of(Time.now)
       end
     end
   end

data/spec/rspec_config.rb

@@ -27,7 +27,7 @@ RSpec.configure do |config|
     WebMock.disable!
   end
 
-  config.before(:example, :webmock => true) do
+  config.before(:example, :webmock) do
     allow(TestApp).to receive(:instance).and_return(instance_double('TestApp',
       app_id: 'app_id',
       key_id: 'app_id.key_id',
@@ -36,4 +36,13 @@ RSpec.configure do |config|
     ))
     WebMock.enable!
   end
+
+  if defined?(EventMachine)
+    config.before(:example) do
+      # Ensure EventMachine shutdown hooks are deregistered for every test
+      EventMachine.instance_variable_set '@tails', []
+    end
+  end
+
+  config.add_formatter Ably::RSpec::PrivateApiFormatter
 end

data/spec/shared/client_initializer_behaviour.rb

@@ -0,0 +1,212 @@
+# encoding: utf-8
+
+shared_examples 'a client initializer' do
+  def subdomain
+    if rest?
+      'rest'
+    else
+      'realtime'
+    end
+  end
+
+  def protocol
+    if rest?
+      'http'
+    else
+      'ws'
+    end
+  end
+
+  def rest?
+    subject.kind_of?(Ably::Rest::Client)
+  end
+
+  context 'with invalid arguments' do
+    context 'empty hash' do
+      let(:client_options) { Hash.new }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(ArgumentError, /api_key is missing/)
+      end
+    end
+
+    context 'nil' do
+      let(:client_options) { nil }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(ArgumentError, /Options Hash is expected/)
+      end
+    end
+
+    context 'api_key: "invalid"' do
+      let(:client_options) { { api_key: 'invalid' } }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(ArgumentError, /api_key is invalid/)
+      end
+    end
+
+    context 'api_key: "invalid:asdad"' do
+      let(:client_options) { { api_key: 'invalid:asdad' } }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(ArgumentError, /api_key is invalid/)
+      end
+    end
+
+    context 'api_key and key_id' do
+      let(:client_options) { { api_key: 'appid.keyuid:keysecret', key_id: 'invalid' } }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(ArgumentError, /api_key and key_id or key_secret are mutually exclusive/)
+      end
+    end
+
+    context 'api_key and key_secret' do
+      let(:client_options) { { api_key: 'appid.keyuid:keysecret', key_secret: 'invalid' } }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(ArgumentError, /api_key and key_id or key_secret are mutually exclusive/)
+      end
+    end
+
+    context 'client_id as only option' do
+      let(:client_options) { { client_id: 'valid' } }
+
+      it 'requires a valid key' do
+        expect { subject }.to raise_error(ArgumentError, /client_id cannot be provided without a complete API key/)
+      end
+    end
+  end
+
+  context 'with valid arguments' do
+    let(:default_options) { { api_key: 'appid.keyuid:keysecret' } }
+    let(:client_options)  { default_options }
+
+    context 'api_key only' do
+      it 'connects to the Ably service' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'key_id and key_secret' do
+      let(:client_options) { { key_id: 'id', key_secret: 'secret' } }
+
+      it 'constructs an api_key' do
+        expect(subject.auth.api_key).to eql('id:secret')
+      end
+    end
+
+    context 'with a string key instead of options hash' do
+      let(:client_options) { 'app.key:secret' }
+
+      it 'sets the api_key' do
+        expect(subject.auth.api_key).to eql(client_options)
+      end
+
+      it 'sets the key_id' do
+        expect(subject.auth.key_id).to eql('app.key')
+      end
+
+      it 'sets the key_secret' do
+        expect(subject.auth.key_secret).to eql('secret')
+      end
+    end
+
+    context 'with token' do
+      let(:client_options) { { token_id: 'token' } }
+
+      it 'sets the token_id' do
+        expect(subject.auth.token_id).to eql('token')
+      end
+    end
+
+    context 'endpoint' do
+      it 'defaults to production' do
+        expect(subject.endpoint.to_s).to eql("#{protocol}s://#{subdomain}.ably.io")
+      end
+
+      context 'with environment option' do
+        let(:client_options) { default_options.merge(environment: 'sandbox') }
+
+        it 'uses an alternate endpoint' do
+          expect(subject.endpoint.to_s).to eql("#{protocol}s://sandbox-#{subdomain}.ably.io")
+        end
+      end
+    end
+
+    context 'tls' do
+      context 'set to false' do
+        let(:client_options) { default_options.merge(tls: false) }
+
+        it 'uses plain text' do
+          expect(subject.use_tls?).to eql(false)
+        end
+
+        it 'uses HTTP' do
+          expect(subject.endpoint.to_s).to eql("#{protocol}://#{subdomain}.ably.io")
+        end
+      end
+
+      it 'defaults to TLS' do
+        expect(subject.use_tls?).to eql(true)
+      end
+    end
+
+    context 'logger' do
+      context 'default' do
+        it 'uses Ruby Logger' do
+          expect(subject.logger.logger).to be_a(::Logger)
+        end
+
+        it 'specifies Logger::ERROR log level' do
+          expect(subject.logger.log_level).to eql(::Logger::ERROR)
+        end
+      end
+
+      context 'with log_level :none' do
+        let(:client_options) { default_options.merge(log_level: :none) }
+
+        it 'silences all logging with a NilLogger' do
+          expect(subject.logger.logger.class).to eql(Ably::Models::NilLogger)
+          expect(subject.logger.log_level).to eql(:none)
+        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
+        let(:client_options) { default_options.merge(logger: custom_logger.new, log_level: Logger::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
+
+  context 'delegators' do
+    let(:client_options) { 'app.key:secret' }
+
+    it 'delegates :client_id to .auth' do
+      expect(subject.auth).to receive(:client_id).and_return('john')
+      expect(subject.client_id).to eql('john')
+    end
+
+    it 'delegates :auth_options to .auth' do
+      expect(subject.auth).to receive(:auth_options).and_return({ option: 1 })
+      expect(subject.auth_options).to eql({ option: 1 })
+    end
+  end
+end

data/spec/{support/model_helper.rb → shared/model_behaviour.rb}

@@ -1,4 +1,4 @@
-require 'securerandom'
+# encoding: utf-8
 
 shared_examples 'a model' do |shared_options = {}|
   let(:base_model_options) { shared_options.fetch(:base_model_options, {}) }
@@ -6,7 +6,7 @@ shared_examples 'a model' do |shared_options = {}|
   let(:model) { subject.new(*args) }
 
   context 'attributes' do
-    let(:unique_value) { SecureRandom.hex }
+    let(:unique_value) { random_str }
 
     Array(shared_options[:with_simple_attributes]).each do |attribute|
       context "##{attribute}" do
@@ -18,7 +18,7 @@ shared_examples 'a model' do |shared_options = {}|
       end
     end
 
-    context '#hash' do
+    context '#hash', :api_private do
       let(:model_options) { { action: 5 } }
 
       it 'provides access to #hash' do
@@ -26,7 +26,7 @@ shared_examples 'a model' do |shared_options = {}|
       end
     end
 
-    context '#[]' do
+    context '#[]', :api_private do
       let(:model_options) { { unusual: 'attribute' } }
 
       it 'provides accessor method to #hash' do
@@ -52,7 +52,7 @@ shared_examples 'a model' do |shared_options = {}|
     end
   end
 
-  context '#to_msgpack' do
+  context '#to_msgpack', :api_private do
     let(:model_options) { { name: 'test', action: 0, channel_snake_case: 'unique' } }
     let(:serialized)    { model.to_msgpack }
 
@@ -61,7 +61,7 @@ shared_examples 'a model' do |shared_options = {}|
     end
   end
 
-  context '#to_json' do
+  context '#to_json', :api_private do
     let(:model_options) { { name: 'test', action: 0, channel_snake_case: 'unique' } }
     let(:serialized)    { model.to_json }
 

data/spec/{support/protocol_msgbus_helper.rb → shared/protocol_msgbus_behaviour.rb}

@@ -1,5 +1,5 @@
 shared_examples 'a protocol message bus' do
-  describe '__protocol_msgbus__ PubSub' do
+  describe '__protocol_msgbus__ PubSub', :api_private do
     let(:protocol_message) do
       Ably::Models::ProtocolMessage.new(
         action: 15,

data/spec/spec_helper.rb

@@ -1,8 +1,17 @@
+# Output the message to the console
+# Useful for debugging as clearly visible, and name is not used anywhere else in library as opposed to debug or puts
+def console(message)
+  puts "\033[31m[#{Time.now.strftime('%H:%M:%S.%L')}]\033[0m \033[33m#{message}\033[0m"
+end
+
 require 'webmock/rspec'
 
 require 'ably'
 
 require 'support/api_helper'
 require 'support/event_machine_helper'
+require 'support/private_api_formatter'
+require 'support/protocol_helper'
+require 'support/random_helper'
 
 require 'rspec_config'

data/spec/support/api_helper.rb

@@ -46,3 +46,14 @@ RSpec.configure do |config|
     TestApp.instance.delete if TestApp.instance_variable_get('@singleton__instance__')
   end
 end
+
+module ApiPreloader
+  def self.included(mod)
+    WebMock.disable!
+    TestApp.instance.api_key
+  end
+
+  RSpec.configure do |config|
+    config.include self, :file_path => %r(spec/acceptance)
+  end
+end