ably 0.1.6 → 0.2.0

data/spec/acceptance/rest/stats_spec.rb

@@ -1,10 +1,10 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
 
-describe "REST" do
+describe 'Ably::Rest Stats' do
   [:json, :msgpack].each do |protocol|
     context "over #{protocol}" do
-      describe "fetching application stats" do
+      describe 'fetching application stats' do
         before(:context) do
           reload_test_app
         end
@@ -40,7 +40,7 @@ describe "REST" do
 
         [:minute, :hour, :day, :month].each do |interval|
           context "by #{interval}" do
-            it "should return all the stats for the application" 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')
 
               expect(stats.size).to eql(1)

data/spec/acceptance/rest/time_spec.rb

@@ -1,14 +1,14 @@
-require "spec_helper"
-require "securerandom"
+require 'spec_helper'
+require 'securerandom'
 
-describe "REST" do
+describe 'Ably::REST 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 "fetching the service time" do
+      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

data/spec/integration/rest/auth.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ably::Auth do
   let(:client) { Ably::Rest::Client.new(key_id: 'id', key_secret: 'secret') }
 
-  it "has immutable options" do
+  it 'has immutable options' do
     expect { client.auth.options['key_id'] = 'new_id' }.to raise_error RuntimeError, /can't modify frozen Hash/
   end
 end

data/spec/resources/crypto-data-128.json

@@ -0,0 +1,56 @@
+{
+  "algorithm": "aes",
+  "mode": "cbc",
+  "keylength": 128,
+  "key": "WUP6u0K7MXI5Zeo0VppPwg==",
+  "iv": "HO4cYSP8LybPYBPZPHQOtg==",
+  "items": [
+    {
+      "encoded": {
+        "name": "example",
+        "data": "The quick brown fox jumped over the lazy dog"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "HO4cYSP8LybPYBPZPHQOtmHItcxYdSvcNUC6kXVpMn0VFL+9z2/5tJ6WFbR0SBT1xhFRuJ+MeBGTU3yOY9P5ow==",
+        "encoding": "utf-8/cipher+aes-128-cbc/base64"
+      }
+    },
+    {
+      "encoded": {
+        "name": "example",
+        "data": "AAECAwQFBgcICQoLDA0ODw==",
+        "encoding": "base64"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "HO4cYSP8LybPYBPZPHQOtuB3dfKG08yw7J4qx3kkjxdW0eoZv+nGAp76OKqYQ327",
+        "encoding": "cipher+aes-128-cbc/base64"
+      }
+    },
+    {
+      "encoded": {
+        "name": "example",
+        "data": "{\"example\":{\"json\":\"Object\"}}",
+        "encoding": "json"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "HO4cYSP8LybPYBPZPHQOtuD53yrD3YV3NBoTEYBh4U0N1QXHbtkfsDfTspKeLQFt",
+        "encoding": "json/utf-8/cipher+aes-128-cbc/base64"
+      }
+    },
+    {
+      "encoded": {
+        "name": "example",
+        "data": "[\"example\",\"json\",\"array\"]",
+        "encoding": "json"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "HO4cYSP8LybPYBPZPHQOtvmStzmExkdjvrn51J6cmaTZrGl+EsJ61sgxmZ6j6jcA",
+        "encoding": "json/utf-8/cipher+aes-128-cbc/base64"
+      }
+    }
+  ]
+}

data/spec/resources/crypto-data-256.json

@@ -0,0 +1,56 @@
+{
+  "algorithm": "aes",
+  "mode": "cbc",
+  "keylength": 256,
+  "key": "o9qXZoPGDNla50VnRwH7cGqIrpyagTxGsRgimKJbY40=",
+  "iv": "NMDl1Acnel8HVdu1cEWdrw==",
+  "items": [
+    {
+      "encoded": {
+        "name": "example",
+        "data": "The quick brown fox jumped over the lazy dog"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "NMDl1Acnel8HVdu1cEWdr9CGPYFoBoLgJCzoybbQbnyfwx3UQ8CGuKyP/g56Za/JB3xW6XGkNzrHYvZwad4fvA==",
+        "encoding": "utf-8/cipher+aes-256-cbc/base64"
+      }
+    },
+    {
+      "encoded": {
+        "name": "example",
+        "data": "AAECAwQFBgcICQoLDA0ODw==",
+        "encoding": "base64"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "NMDl1Acnel8HVdu1cEWdr8UFEi56Ms0zPHszbppM61BC8Yf6ndq+kiCj9xXW97/O",
+        "encoding": "cipher+aes-256-cbc/base64"
+      }
+    },
+    {
+      "encoded": {
+        "name": "example",
+        "data": "{\"example\":{\"json\":\"Object\"}}",
+        "encoding": "json"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "NMDl1Acnel8HVdu1cEWdr21pS5//hdtQf3QqQzZM/jWAtn09Vh52E6jMdC3mWS98",
+        "encoding": "json/utf-8/cipher+aes-256-cbc/base64"
+      }
+    },
+    {
+      "encoded": {
+        "name": "example",
+        "data": "[\"example\",\"json\",\"array\"]",
+        "encoding": "json"
+      },
+      "encrypted": {
+        "name": "example",
+        "data": "NMDl1Acnel8HVdu1cEWdr4J5sVAFpnXsz0fTtsuwOaTRU+6P5GaWlNjePWwiOZCQ",
+        "encoding": "json/utf-8/cipher+aes-256-cbc/base64"
+      }
+    }
+  ]
+}

data/spec/rspec_config.rb

@@ -0,0 +1,39 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.mock_with :rspec do |mocks|
+    # This option should be set when all dependencies are being loaded
+    # before a spec run, as is the case in a typical spec helper. It will
+    # cause any verifying double instantiation for a class that does not
+    # exist to raise, protecting against incorrectly spelt names.
+    mocks.verify_doubled_constant_names = true
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.before(:example) do
+    WebMock.disable!
+  end
+
+  config.before(:example, :webmock => true) do
+    allow(TestApp).to receive(:instance).and_return(instance_double('TestApp',
+      app_id: 'app_id',
+      key_id: 'app_id.key_id',
+      api_key: 'app_id.key_id:secret',
+      environment: 'sandbox'
+    ))
+    WebMock.enable!
+  end
+end

data/spec/spec_helper.rb

@@ -1,46 +1,8 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-
 require 'webmock/rspec'
 
-require "ably"
-
-require "support/api_helper"
-require "support/event_machine_helper"
-
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  config.mock_with :rspec do |mocks|
-    # This option should be set when all dependencies are being loaded
-    # before a spec run, as is the case in a typical spec helper. It will
-    # cause any verifying double instantiation for a class that does not
-    # exist to raise, protecting against incorrectly spelt names.
-    mocks.verify_doubled_constant_names = true
-  end
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
+require 'ably'
 
-  config.before(:example) do
-    WebMock.disable!
-  end
+require 'support/api_helper'
+require 'support/event_machine_helper'
 
-  config.before(:example, :webmock => true) do
-    allow(TestApp).to receive(:instance).and_return(instance_double('TestApp',
-      app_id: 'app_id',
-      key_id: 'app_id.key_id',
-      api_key: 'app_id.key_id:secret',
-      environment: 'sandbox'
-    ))
-    WebMock.enable!
-  end
-end
+require 'rspec_config'

data/spec/support/api_helper.rb

@@ -1,4 +1,4 @@
-require "support/test_app"
+require 'support/test_app'
 
 module ApiHelper
   def app_id

data/spec/support/event_machine_helper.rb

@@ -6,11 +6,6 @@ module RSpec
       Timeout::timeout(timeout + 0.5) do
         EM.run do
           yield
-
-          EM.add_timer(timeout) do
-            EM.stop
-            raise RuntimeError, "EventMachine test did not complete in #{timeout} seconds"
-          end
         end
       end
     end

data/spec/support/protocol_msgbus_helper.rb

@@ -1,6 +1,6 @@
 shared_examples 'a protocol message bus' do
   describe '__protocol_msgbus__ PubSub' do
-    let(:message) do
+    let(:protocol_message) do
       Ably::Models::ProtocolMessage.new(
         action: 15,
         channel: 'channel',
@@ -11,8 +11,8 @@ shared_examples 'a protocol message bus' do
 
     specify 'supports valid ProtocolMessage messages' do
       received = 0
-      msgbus.subscribe(:message) { received += 1 }
-      expect { msgbus.publish(:message, message) }.to change { received }.to(1)
+      msgbus.subscribe(:protocol_message) { received += 1 }
+      expect { msgbus.publish(:protocol_message, protocol_message) }.to change { received }.to(1)
     end
 
     specify 'fail with unacceptable STATE event names' do

data/spec/support/test_app.rb

@@ -1,4 +1,4 @@
-require "singleton"
+require 'singleton'
 
 class TestApp
   APP_SPEC = {
@@ -81,8 +81,8 @@ class TestApp
     url = "#{sandbox_client.endpoint}/apps"
 
     headers = {
-      "Accept"       => "application/json",
-      "Content-Type" => "application/json"
+      'Accept'       => 'application/json',
+      'Content-Type' => 'application/json'
     }
 
     response = Faraday.post(url, APP_SPEC.to_json, headers)

data/spec/unit/logger_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Ably::Logger do
+  let(:new_client) do
+    instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: nil))
+  end
+  let(:connected_client) do
+    instance_double('Ably::Realtime::Client', connection: instance_double('Ably::Realtime::Connection', id: '0000'))
+  end
+  let(:rest_client) do
+    instance_double('Ably::Rest::Client')
+  end
+
+  subject { Ably::Logger.new(new_client, Logger::INFO) }
+
+  def uncolorize(string)
+    regex_pattern = /\033\[[0-9]+m(.+?)\033\[0m/m
+    string.gsub(regex_pattern, '\1')
+  end
+
+  it 'uses the Ruby Logger by default' do
+    expect(subject.logger).to be_a(Logger)
+  end
+
+  it 'delegates to the logger object' do
+    expect(subject.logger).to receive(:warn).with('message')
+    subject.warn 'message'
+  end
+
+  context 'formatter' do
+    context 'when debugging' do
+      it 'uses short time format' do
+        formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+        formatted = uncolorize(formatted)
+        expect(formatted).to match(/^\d+:\d+:\d+.\d{3} DEBUG/)
+      end
+    end
+
+    context 'when info -> fatal' do
+      it 'uses long time format' do
+        formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
+        formatted = uncolorize(formatted)
+        expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+      end
+    end
+
+    context 'with Realtime disconnected client' do
+      subject { Ably::Logger.new(new_client, Logger::INFO) }
+
+      it 'formats logs with an empty client ID' do
+        formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+        formatted = uncolorize(formatted)
+        expect(formatted).to match(/\[ \-\- \]/)
+        expect(formatted).to match(%r{unique_message$})
+        expect(formatted).to match(%r{DEBUG})
+      end
+    end
+
+    context 'with Realtime connected client' do
+      subject { Ably::Logger.new(connected_client, Logger::INFO) }
+
+      it 'formats logs with a client ID' do
+        formatted = subject.logger.formatter.call(Logger::DEBUG, Time.now, 'progid', 'unique_message')
+        formatted = uncolorize(formatted)
+        expect(formatted).to match(/\[0000]/)
+        expect(formatted).to match(%r{unique_message$})
+        expect(formatted).to match(%r{DEBUG})
+      end
+    end
+
+    context 'with REST client' do
+      subject { Ably::Logger.new(rest_client, Logger::INFO) }
+
+      it 'formats logs without a client ID' do
+        formatted = subject.logger.formatter.call(Logger::FATAL, Time.now, 'progid', 'unique_message')
+        formatted = uncolorize(formatted)
+        expect(formatted).to_not match(/\[.*\]/)
+        expect(formatted).to match(%r{unique_message$})
+        expect(formatted).to match(%r{FATAL})
+      end
+    end
+
+    context 'severity argument' do
+      it 'can be an Integer' do
+        formatted = subject.logger.formatter.call(Logger::INFO, Time.now, 'progid', 'unique_message')
+        formatted = uncolorize(formatted)
+        expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+      end
+
+      it 'can be a string' do
+        formatted = subject.logger.formatter.call('INFO', Time.now, 'progid', 'unique_message')
+        formatted = uncolorize(formatted)
+        expect(formatted).to match(/^\d+-\d+-\d+ \d+:\d+:\d+.\d{3} INFO/)
+      end
+    end
+  end
+
+  context 'with a custom Logger' do
+    context 'with an invalid interface' do
+      let(:custom_logger_with_bad_interface) do
+        Class.new.new
+      end
+      subject { Ably::Logger.new(new_client, Logger::INFO, custom_logger_with_bad_interface) }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error ArgumentError, /The custom Logger's interface does not provide the method/
+      end
+    end
+
+    context 'with a valid interface' 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(:custom_logger_object) { custom_logger.new }
+
+      subject { Ably::Logger.new(new_client, Logger::INFO, custom_logger_object) }
+
+      it 'is used' do
+        expect { subject }.to_not raise_error
+        expect(subject.logger.class).to eql(custom_logger)
+      end
+
+      it 'delegates log messages to logger' do
+        expect(custom_logger_object).to receive(:fatal).with('message')
+        subject.fatal 'message'
+      end
+    end
+  end
+end