ably-rest 0.7.1 → 0.7.3

data/lib/submodules/ably-ruby/spec/unit/models/stat_spec.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::Stat do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::Stat }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(interval_id all inbound outbound persisted connections channels api_requests token_requests) do
+    let(:model_args) { [] }
+  end
+
+  describe '#interval_granularity' do
+    subject { Ably::Models::Stat.new(interval_id: '2004-02') }
+
+    it 'returns the granularity of the interval_id' do
+      expect(subject.interval_granularity).to eq(:month)
+    end
+  end
+
+  describe '#interval_time' do
+    subject { Ably::Models::Stat.new(interval_id: '2004-02-01:05:06') }
+
+    it 'returns a Time object representing the start of the interval' do
+      expect(subject.interval_time.to_i).to eql(Time.new(2004, 02, 01, 05, 06, 00, '+00:00').to_i)
+    end
+  end
+
+  context 'class methods' do
+    describe '#to_interval_id' do
+      context 'when time zone of time argument is UTC' do
+        it 'converts time 2014-02-03:05:06 with granularity :month into 2014-02' do
+          expect(subject.to_interval_id(Time.new(2014, 2, 1, 0, 0, 0, '+00:00'), :month)).to eql('2014-02')
+        end
+
+        it 'converts time 2014-02-03:05:06 with granularity :day into 2014-02-03' do
+          expect(subject.to_interval_id(Time.new(2014, 2, 3, 0, 0, 0, '+00:00'), :day)).to eql('2014-02-03')
+        end
+
+        it 'converts time 2014-02-03:05:06 with granularity :hour into 2014-02-03:05' do
+          expect(subject.to_interval_id(Time.new(2014, 2, 3, 5, 0, 0, '+00:00'), :hour)).to eql('2014-02-03:05')
+        end
+
+        it 'converts time 2014-02-03:05:06 with granularity :minute into 2014-02-03:05:06' do
+          expect(subject.to_interval_id(Time.new(2014, 2, 3, 5, 6, 0, '+00:00'), :minute)).to eql('2014-02-03:05:06')
+        end
+
+        it 'fails with invalid granularity' do
+          expect { subject.to_interval_id(Time.now, :invalid) }.to raise_error KeyError
+        end
+
+        it 'fails with invalid time' do
+          expect { subject.to_interval_id(nil, :month) }.to raise_error ArgumentError
+        end
+      end
+
+      context 'when time zone of time argument is +02:00' do
+        it 'converts time 2014-02-03:06 with granularity :hour into 2014-02-03:04 at UTC +00:00' do
+          expect(subject.to_interval_id(Time.new(2014, 2, 3, 6, 0, 0, '+02:00'), :hour)).to eql('2014-02-03:04')
+        end
+      end
+    end
+
+    describe '#from_interval_id' do
+      it 'converts a month interval_id 2014-02 into a Time object in UTC 0' do
+        expect(subject.from_interval_id('2014-02')).to eql(Time.new(2014, 2))
+        expect(subject.from_interval_id('2014-02').utc_offset).to eql(0)
+      end
+
+      it 'converts a day interval_id 2014-02-03 into a Time object in UTC 0' do
+        expect(subject.from_interval_id('2014-02-03')).to eql(Time.new(2014, 2, 3))
+        expect(subject.from_interval_id('2014-02-03').utc_offset).to eql(0)
+      end
+
+      it 'converts an hour interval_id 2014-02-03:05 into a Time object in UTC 0' do
+        expect(subject.from_interval_id('2014-02-03:05')).to eql(Time.new(2014, 2, 3, 5))
+        expect(subject.from_interval_id('2014-02-03:05').utc_offset).to eql(0)
+      end
+
+      it 'converts a minute interval_id 2014-02-03:05:06 into a Time object in UTC 0' do
+        expect(subject.from_interval_id('2014-02-03:05:06')).to eql(Time.new(2014, 2, 3, 5, 6))
+        expect(subject.from_interval_id('2014-02-03:05:06').utc_offset).to eql(0)
+      end
+
+      it 'fails with an invalid interval_id 14-20' do
+        expect { subject.from_interval_id('14-20') }.to raise_error ArgumentError
+      end
+    end
+
+    describe '#granularity_from_interval_id' do
+      it 'returns a :month interval_id for 2014-02' do
+        expect(subject.granularity_from_interval_id('2014-02')).to eq(:month)
+      end
+
+      it 'returns a :day interval_id for 2014-02-03' do
+        expect(subject.granularity_from_interval_id('2014-02-03')).to eq(:day)
+      end
+
+      it 'returns a :hour interval_id for 2014-02-03:05' do
+        expect(subject.granularity_from_interval_id('2014-02-03:05')).to eq(:hour)
+      end
+
+      it 'returns a :minute interval_id for 2014-02-03:05:06' do
+        expect(subject.granularity_from_interval_id('2014-02-03:05:06')).to eq(:minute)
+      end
+
+      it 'fails with an invalid interval_id 14-20' do
+        expect { subject.granularity_from_interval_id('14-20') }.to raise_error ArgumentError
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/models/token_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Ably::Models::Token do
+  subject { Ably::Models::Token }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(id capability client_id nonce) do
+    let(:model_args) { [] }
+  end
+
+  context 'defaults' do
+    let(:one_hour)          { 60 * 60 }
+    let(:all_capabilities)  { { "*" => ["*"] } }
+
+    it 'should default TTL to 1 hour' do
+      expect(Ably::Models::Token::DEFAULTS[:ttl]).to eql(one_hour)
+    end
+
+    it 'should default capability to all' do
+      expect(Ably::Models::Token::DEFAULTS[:capability]).to eql(all_capabilities)
+    end
+
+    it 'should only have defaults for :ttl and :capability' do
+      expect(Ably::Models::Token::DEFAULTS.keys).to contain_exactly(:ttl, :capability)
+    end
+  end
+
+  context 'attributes' do
+    let(:unique_value) { 'unique_value' }
+
+    context '#key_id' do
+      subject { Ably::Models::Token.new({ key: unique_value }) }
+      it 'retrieves attribute :key' do
+        expect(subject.key_id).to eql(unique_value)
+      end
+    end
+
+    { :issued_at => :issued_at, :expires_at => :expires }.each do |method_name, attribute|
+      let(:time) { Time.now }
+      context "##{method_name}" do
+        subject { Ably::Models::Token.new({ attribute.to_sym => time.to_i }) }
+
+        it "retrieves attribute :#{attribute} as Time" do
+          expect(subject.public_send(method_name)).to be_a(Time)
+          expect(subject.public_send(method_name).to_i).to eql(time.to_i)
+        end
+      end
+    end
+
+    context '#expired?' do
+      let(:expire_time) { Time.now + Ably::Models::Token::TOKEN_EXPIRY_BUFFER }
+
+      context 'once grace period buffer has passed' do
+        subject { Ably::Models::Token.new(expires: expire_time - 1) }
+
+        it 'is true' do
+          expect(subject.expired?).to eql(true)
+        end
+      end
+
+      context 'within grace period buffer' do
+        subject { Ably::Models::Token.new(expires: expire_time + 1) }
+
+        it 'is false' do
+          expect(subject.expired?).to eql(false)
+        end
+      end
+    end
+  end
+
+  context '==' do
+    let(:token_attributes) { { id: 'unique' } }
+
+    it 'is true when attributes are the same' do
+      new_token = -> { Ably::Models::Token.new(token_attributes) }
+      expect(new_token[]).to eq(new_token[])
+    end
+
+    it 'is false when attributes are not the same' do
+      expect(Ably::Models::Token.new(id: 1)).to_not eq(Ably::Models::Token.new(id: 2))
+    end
+
+    it 'is false when class type differs' do
+      expect(Ably::Models::Token.new(id: 1)).to_not eq(nil)
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/modules/async_wrapper_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Ably::Modules::AsyncWrapper, :api_private do
+  include RSpec::EventMachine
+
+  let(:class_with_module) do
+    Class.new do
+      include Ably::Modules::AsyncWrapper
+
+      def operation(&success_callback)
+        async_wrap success_callback, &@block
+      end
+
+      def block=(block)
+        @block = block
+      end
+    end
+  end
+  let(:subject)    { class_with_module.new }
+  let(:result)     { random_str }
+  let(:sleep_time) { 0.1 }
+
+  before do
+    subject.block = block
+  end
+
+  context '#async_wrap blocking block' do
+    context 'returns result' do
+      let(:block) do
+        proc do
+          sleep sleep_time
+          result
+        end
+      end
+
+      it 'calls the success_callback block with result when provided' do
+        run_reactor do
+          subject.operation do |result|
+            expect(result).to eql(result)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'returns a deferrable that succeeds with result' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.callback do |result|
+            expect(result).to eql(result)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'does not call the errback' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.callback do |result|
+            expect(result).to eql(result)
+            EventMachine.add_timer(sleep_time * 2) { stop_reactor }
+          end
+          deferrable.errback do |result|
+            raise 'Errback should not have been called'
+          end
+        end
+      end
+
+      it 'does not block EventMachine' do
+        run_reactor do
+          timers_called = 0
+          EventMachine.add_periodic_timer(sleep_time / 5) { timers_called += 1 }
+
+          subject.operation do |result|
+            expect(timers_called).to be >= 4
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context 'raises an Exception' do
+      let(:block) do
+        proc do
+          sleep sleep_time
+          raise RuntimeError, 'Intentional'
+        end
+      end
+
+      it 'calls the errback block of the deferrable' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.errback do |error|
+            expect(error).to be_a(RuntimeError)
+            expect(error.message).to match(/Intentional/)
+            stop_reactor
+          end
+        end
+      end
+
+      it 'does not call the success_callback block' do
+        run_reactor do
+          subject.operation do |result|
+            raise 'Callback should not have been called'
+          end
+          EventMachine.add_timer(sleep_time * 2) { stop_reactor }
+        end
+      end
+
+      it 'does not call the callback block of the deferrable' do
+        run_reactor do
+          deferrable = subject.operation
+          expect(deferrable).to be_a(EventMachine::Deferrable)
+          deferrable.callback do |result|
+            raise 'Callback should not have been called'
+          end
+          EventMachine.add_timer(sleep_time * 2) { stop_reactor }
+        end
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/modules/conversions_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Ably::Modules::Conversions, :api_private do
+  let(:class_with_module) { Class.new do; include Ably::Modules::Conversions; end }
+  let(:subject) { class_with_module.new }
+  before do
+    # make method being tested public
+    class_with_module.class_eval %{ public :#{method} }
+  end
+
+  context '#as_since_epoch' do
+    let(:method) { :as_since_epoch }
+
+    context 'with time' do
+      let(:time) { Time.new }
+
+      it 'converts to milliseconds by default' do
+        expect(subject.as_since_epoch(time)).to be_within(1).of(time.to_f * 1_000)
+      end
+
+      it 'converted to seconds' do
+        expect(subject.as_since_epoch(time, granularity: :s)).to eql(time.to_i)
+      end
+    end
+
+    context 'with numeric' do
+      it 'converts to integer' do
+        expect(subject.as_since_epoch(1.01)).to eql(1)
+      end
+
+      it 'accepts integers' do
+        expect(subject.as_since_epoch(1)).to eql(1)
+      end
+    end
+
+    context 'with any other object' do
+      it 'raises an exception' do
+        expect { subject.as_since_epoch(Object.new) }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  context '#as_time_from_epoch' do
+    let(:method) { :as_time_from_epoch }
+    let(:time) { Time.new }
+
+    context 'with numeric' do
+      let(:millisecond) { Time.new.to_f * 1_000 }
+      let(:seconds) { Time.new.to_f }
+
+      it 'converts to Time from milliseconds by default' do
+        expect(subject.as_time_from_epoch(millisecond).to_f).to be_within(0.01).of(time.to_f)
+      end
+
+      it 'converts to Time from seconds' do
+        expect(subject.as_time_from_epoch(seconds, granularity: :s).to_i).to eql(time.to_i)
+      end
+    end
+
+    context 'with Time' do
+      it 'leaves intact' do
+        expect(subject.as_time_from_epoch(time)).to eql(time)
+      end
+    end
+
+    context 'with any other object' do
+      it 'raises an exception' do
+        expect { subject.as_time_from_epoch(Object.new) }.to raise_error ArgumentError
+      end
+    end
+  end
+end

data/lib/submodules/ably-ruby/spec/unit/modules/enum_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+
+describe Ably::Modules::Enum, :api_private do
+  class ExampleClassWithEnum
+    extend Ably::Modules::Enum
+    ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', :value_zero, 'value_1', :value_snake_case_2, :SentenceCase)
+  end
+
+  let(:enum) { ExampleClassWithEnum::ENUMEXAMPLE }
+  let(:enum_name) { 'ENUMEXAMPLE' }
+
+  context 'convertor method added to class' do
+    subject { ExampleClassWithEnum }
+
+    it 'converts symbols' do
+      expect(subject.ENUMEXAMPLE(:value_zero)).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts strings' do
+      expect(subject.ENUMEXAMPLE('ValueZero')).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts integer index' do
+      expect(subject.ENUMEXAMPLE(0)).to eql(enum.get(:value_zero))
+    end
+  end
+
+  context 'convertor method added to instance' do
+    subject { ExampleClassWithEnum.new }
+
+    it 'converts symbols' do
+      expect(subject.ENUMEXAMPLE(:value_zero)).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts strings' do
+      expect(subject.ENUMEXAMPLE('ValueZero')).to eql(enum.get(:value_zero))
+    end
+
+    it 'converts integer index' do
+      expect(subject.ENUMEXAMPLE(0)).to eql(enum.get(:value_zero))
+    end
+  end
+
+  context 'defined Enum from Array class' do
+    subject { enum }
+
+    it 'provides a MixedCase const for each provided value' do
+      expect(subject.ValueZero).to be_a(subject)
+      expect(subject.ValueSnakeCase2).to be_a(subject)
+    end
+
+    context '#get' do
+      context 'by integer index' do
+        let(:return_val) { subject.get(0) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_zero)
+        end
+      end
+
+      context 'by string value' do
+        let(:return_val) { subject.get('value_zero') }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_zero)
+        end
+      end
+
+      context 'by symbol' do
+        let(:return_val) { subject.get(:sentence_case) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:sentence_case)
+        end
+      end
+
+      context 'by enum' do
+        let(:return_val) { subject.get(subject.get(:sentence_case)) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:sentence_case)
+        end
+      end
+
+      context 'by invalid type' do
+        let(:return_val) { subject.get(Array.new) }
+        it 'raises an error' do
+          expect { return_val }.to raise_error KeyError
+        end
+      end
+    end
+
+    context '#[]' do
+      let(:argument) { random_str }
+      before do
+        expect(subject).to receive(:get).with(argument).once.and_return(true)
+      end
+
+      it 'is an alias for get' do
+        subject[argument]
+      end
+    end
+
+    it 'returns the provided Enum name' do
+      expect(subject.name).to eql(enum_name)
+    end
+
+    specify '#to_s returns the Enum name' do
+      expect("#{subject}").to eql(enum_name)
+    end
+
+    context '#size' do
+      it 'returns the number of enum items' do
+        expect(subject.size).to eql(4)
+      end
+
+      it 'has alias #length' do
+        expect(subject.length).to eql(subject.size)
+      end
+    end
+
+    it 'freezes the Enum' do
+      expect(subject.send(:by_index)).to be_frozen
+    end
+
+    it 'prevents modification' do
+      expect { subject.send(:define_values, :enum_id) }.to raise_error RuntimeError, /cannot be modified/
+    end
+
+    it 'behaves like Enumerable' do
+      expect(subject.map(&:to_sym)).to eql([:value_zero, :value_1, :value_snake_case_2, :sentence_case])
+    end
+
+    context '#each' do
+      it 'returns an enumerator' do
+        expect(subject.each).to be_a(Enumerator)
+      end
+
+      it 'yields each channel' do
+        expect(subject.each.map(&:to_sym)).to eql([:value_zero, :value_1, :value_snake_case_2, :sentence_case])
+      end
+    end
+  end
+
+  context 'defined Enum from Hash class' do
+    class ExampleClassWithEnumFromHash
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE',
+        value_one:  1,
+        value_five: 5
+      )
+    end
+
+    subject { ExampleClassWithEnumFromHash::ENUMEXAMPLE }
+
+    it 'provides a MixedCase const for each provided value' do
+      expect(subject.ValueOne).to be_a(subject)
+      expect(subject.ValueFive).to be_a(subject)
+    end
+
+    context '#get' do
+      context 'by integer index for 1' do
+        let(:return_val) { subject.get(1) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_one)
+        end
+      end
+
+      context 'by integer index for 5' do
+        let(:return_val) { subject.get(5) }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_five)
+        end
+      end
+
+      context 'by invalid integer index' do
+        let(:return_val) { subject.get(0) }
+        it 'raises an exception' do
+          expect { return_val }.to raise_error KeyError
+        end
+      end
+
+      context 'by string value' do
+        let(:return_val) { subject.get('value_five') }
+        it 'returns an enum' do
+          expect(return_val).to be_a(subject)
+          expect(return_val.to_sym).to eql(:value_five)
+          expect(return_val.to_i).to eql(5)
+        end
+      end
+    end
+  end
+
+  context 'defined Enum from another Enum' do
+    class ExampleBaseEnum
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', :one, :second_enum)
+    end
+
+    class ExampleOtherEnum
+      extend Ably::Modules::Enum
+      ENUMEXAMPLE = ruby_enum('ENUMEXAMPLE', ExampleBaseEnum::ENUMEXAMPLE)
+    end
+
+    subject { ExampleOtherEnum::ENUMEXAMPLE }
+
+    it 'provides a MixedCase const for each provided value' do
+      expect(subject.One).to be_a(subject)
+      expect(subject.SecondEnum).to be_a(subject)
+    end
+  end
+
+  context 'Enum instance' do
+    context '#==' do
+      subject { enum.get(:value_snake_case_2) }
+
+      it 'compares with a symbol' do
+        expect(subject).to eq(:value_Snake_Case_2)
+      end
+
+      it 'compares with a string' do
+        expect(subject).to eq('ValueSnakeCase2')
+      end
+
+      it 'compares with a integer index' do
+        expect(subject).to eq(subject.to_i)
+      end
+
+      it 'compares with itself' do
+        expect(subject).to eq(subject)
+      end
+
+      it 'compares with other Objects' do
+        expect(subject).to_not eq(Object.new)
+      end
+    end
+
+    context '#to_s' do
+      subject { enum.get(:value_zero) }
+
+      it 'returns ENUMNAME.CamelCase name' do
+        expect(subject.to_s).to eql("#{enum_name}.ValueZero")
+      end
+    end
+
+    context '#to_sym' do
+      subject { enum.get(:value_zero) }
+
+      it 'returns a snake_case symbol' do
+        expect(subject.to_sym).to eql(:value_zero)
+      end
+    end
+
+    context '#to_i' do
+      subject { enum.get(:value_1) }
+
+      it 'returns the Enum index' do
+        expect(subject.to_i).to eql(1)
+      end
+    end
+
+    context '#to_json' do
+      subject { enum.get(:value_1) }
+
+      it 'returns a symbol string key value' do
+        expect(subject.to_json).to eql('"value_1"')
+      end
+    end
+  end
+end