ably-rest 0.7.1 → 0.7.3

data/lib/submodules/ably-ruby/spec/acceptance/rest/stats_spec.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Ably::Rest::Client, '#stats' do
+  include Ably::Modules::Conversions
+
+  LAST_YEAR = Time.now.year - 1
+  LAST_INTERVAL = Time.new(LAST_YEAR, 2, 3, 15, 5, 0) # 3rd Feb 20(x) 16:05:00
+
+  STATS_FIXTURES = [
+    {
+      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL - 120, :minute),
+      inbound:  { realtime: { messages: { count: 50, data: 5000 } } },
+      outbound: { realtime: { messages: { count: 20, data: 2000 } } }
+    },
+    {
+      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL - 60, :minute),
+      inbound:  { realtime: { messages: { count: 60, data: 6000 } } },
+      outbound: { realtime: { messages: { count: 10, data: 1000 } } }
+    },
+    {
+      intervalId: Ably::Models::Stat.to_interval_id(LAST_INTERVAL, :minute),
+      inbound:       { realtime: { messages: { count: 70, data: 7000 } } },
+      outbound:      { realtime: { messages: { count: 40, data: 4000 } } },
+      persisted:     { presence: { count: 20, data: 2000 } },
+      connections:   { tls:      { peak: 20,  opened: 10 } },
+      channels:      { peak: 50, opened: 30 },
+      apiRequests:   { succeeded: 50, failed: 10 },
+      tokenRequests: { succeeded: 60, failed: 20 },
+    }
+  ]
+
+  before(:context) do
+    reload_test_app # ensure no previous stats interfere
+    TestApp.instance.create_test_stats(STATS_FIXTURES)
+  end
+
+  vary_by_protocol do
+    let(:client) {  Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol) }
+
+    describe 'fetching application stats' do
+      context 'by minute' do
+        let(:first_inbound_realtime_count) { STATS_FIXTURES.first[:inbound][:realtime][:messages][:count] }
+        let(:last_inbound_realtime_count)  { STATS_FIXTURES.last[:inbound][:realtime][:messages][:count] }
+
+        context 'with :from set to last interval and :limit set to 1' do
+          let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), by: :minute, limit: 1) }
+          let(:stat)    { subject.first}
+
+          it 'retrieves only one stat' do
+            expect(subject.count).to eql(1)
+          end
+
+          it 'returns all aggregated message data' do
+            expect(stat.all[:messages][:count]).to eql(70 + 40) # inbound + outbound
+            expect(stat.all[:messages][:data]).to eql(7000 + 4000) # inbound + outbound
+          end
+
+          it 'returns inbound realtime all data' do
+            expect(stat.inbound[:realtime][:all][:count]).to eql(70)
+            expect(stat.inbound[:realtime][:all][:data]).to eql(7000)
+          end
+
+          it 'returns inbound realtime message data' do
+            expect(stat.inbound[:realtime][:messages][:count]).to eql(70)
+            expect(stat.inbound[:realtime][:messages][:data]).to eql(7000)
+          end
+
+          it 'returns outbound realtime all data' do
+            expect(stat.outbound[:realtime][:all][:count]).to eql(40)
+            expect(stat.outbound[:realtime][:all][:data]).to eql(4000)
+          end
+
+          it 'returns persisted presence all data' do
+            expect(stat.persisted[:all][:count]).to eql(20)
+            expect(stat.persisted[:all][:data]).to eql(2000)
+          end
+
+          it 'returns connections all data' do
+            expect(stat.connections[:tls][:peak]).to eql(20)
+            expect(stat.connections[:tls][:opened]).to eql(10)
+          end
+
+          it 'returns channels all data' do
+            expect(stat.channels[:peak]).to eql(50)
+            expect(stat.channels[:opened]).to eql(30)
+          end
+
+          it 'returns api_requests data' do
+            expect(stat.api_requests[:succeeded]).to eql(50)
+            expect(stat.api_requests[:failed]).to eql(10)
+          end
+
+          it 'returns token_requests data' do
+            expect(stat.token_requests[:succeeded]).to eql(60)
+            expect(stat.token_requests[:failed]).to eql(20)
+          end
+
+          it 'returns stat objects with #interval_granularity equal to :minute' do
+            expect(stat.interval_granularity).to eq(:minute)
+          end
+
+          it 'returns stat objects with #interval_id matching :start' do
+            expect(stat.interval_id).to eql(LAST_INTERVAL.strftime('%Y-%m-%d:%H:%M'))
+          end
+
+          it 'returns stat objects with #interval_time matching :start Time' do
+            expect(stat.interval_time.to_i).to eql(LAST_INTERVAL.to_i)
+          end
+        end
+
+        context 'with :start set to first interval, :limit set to 1 and direction :forwards' do
+          let(:first_interval) { LAST_INTERVAL - 120 }
+          let(:subject)        { client.stats(start: as_since_epoch(first_interval), by: :minute, direction: :forwards, limit: 1) }
+          let(:stat)           { subject.first}
+
+          it 'returns the first interval stats as stats are provided forwards from :start' do
+            expect(stat.inbound[:realtime][:all][:count]).to eql(first_inbound_realtime_count)
+          end
+
+          it 'returns 3 pages of stats' do
+            expect(subject).to be_first_page
+            expect(subject).to_not be_last_page
+            page3 = subject.next_page.next_page
+            expect(page3).to be_last_page
+            expect(page3.first.inbound[:realtime][:all][:count]).to eql(last_inbound_realtime_count)
+          end
+        end
+
+        context 'with :end set to last interval, :limit set to 1 and direction :backwards' do
+          let(:subject)        { client.stats(:end => as_since_epoch(LAST_INTERVAL), by: :minute, direction: :backwards, limit: 1) }
+          let(:stat)           { subject.first}
+
+          it 'returns the 3rd interval stats first as stats are provided backwards from :end' do
+            expect(stat.inbound[:realtime][:all][:count]).to eql(last_inbound_realtime_count)
+          end
+
+          it 'returns 3 pages of stats' do
+            expect(subject).to be_first_page
+            expect(subject).to_not be_last_page
+            page3 = subject.next_page.next_page
+            expect(page3.first.inbound[:realtime][:all][:count]).to eql(first_inbound_realtime_count)
+          end
+        end
+      end
+
+      [:hour, :day, :month].each do |interval|
+        context "by #{interval}" do
+          let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), by: interval, direction: 'forwards', limit: 1) }
+          let(:stat)    { subject.first }
+          let(:aggregate_messages_count) do
+            STATS_FIXTURES.inject(0) do |sum, fixture|
+              sum + fixture[:inbound][:realtime][:messages][:count] + fixture[:outbound][:realtime][:messages][:count]
+            end
+          end
+          let(:aggregate_messages_data) do
+            STATS_FIXTURES.inject(0) do |sum, fixture|
+              sum + fixture[:inbound][:realtime][:messages][:data] + fixture[:outbound][:realtime][:messages][:data]
+            end
+          end
+
+          it 'should aggregate the stats for that period' do
+            expect(subject.count).to eql(1)
+
+            expect(stat.all[:messages][:count]).to eql(aggregate_messages_count)
+            expect(stat.all[:messages][:data]).to eql(aggregate_messages_data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/acceptance/rest/time_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+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
+    end
+  end
+end

data/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/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/lib/submodules/ably-ruby/spec/rspec_config.rb

@@ -0,0 +1,57 @@
+# 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 'rspec/retry'
+
+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) 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
+
+  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
+
+  if ENV['RSPEC_RETRY']
+    puts 'Running tests using RSpec retry'
+    config.verbose_retry = true # show retry status in spec process
+    config.default_retry_count = 3
+    config.default_sleep_interval = 2
+  end
+end

data/lib/submodules/ably-ruby/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