ably-rest 0.7.5 → 0.8.1

data/lib/submodules/ably-ruby/spec/unit/auth_spec.rb

@@ -4,7 +4,7 @@ require 'shared/protocol_msgbus_behaviour'
 describe Ably::Auth do
   let(:client)    { double('client').as_null_object }
   let(:client_id) { nil }
-  let(:options)   { { api_key: 'appid.keyuid:keysecret', client_id: client_id } }
+  let(:options)   { { key: 'appid.keyuid:keysecret', client_id: client_id } }
 
   subject do
     Ably::Auth.new(client, options)
@@ -65,4 +65,21 @@ describe Ably::Auth do
       end
     end
   end
+
+  context 'defaults' do
+    let(:one_hour)          { 60 * 60 }
+    let(:all_capabilities)  { { "*" => ["*"] } }
+
+    it 'should default TTL to 1 hour' do
+      expect(Ably::Auth::TOKEN_DEFAULTS.fetch(:ttl)).to eql(one_hour)
+    end
+
+    it 'should default capability to all' do
+      expect(Ably::Auth::TOKEN_DEFAULTS.fetch(:capability)).to eql(all_capabilities)
+    end
+
+    it 'should only have defaults for :ttl and :capability' do
+      expect(Ably::Auth::TOKEN_DEFAULTS.keys).to contain_exactly(:ttl, :capability)
+    end
+  end
 end

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

@@ -5,7 +5,7 @@ describe Ably::Models::PaginatedResource do
   let(:paginated_resource_class) { Ably::Models::PaginatedResource }
   let(:headers) { Hash.new }
   let(:client) do
-    instance_double('Ably::Rest::Client', logger: true).tap do |client|
+    instance_double('Ably::Rest::Client', logger: Ably::Models::NilLogger.new).tap do |client|
       allow(client).to receive(:get).and_return(http_response)
     end
   end
@@ -27,57 +27,54 @@ describe Ably::Models::PaginatedResource do
   let(:first_paged_request) { paginated_resource_class.new(http_response, full_url, client, paginated_resource_options) }
   subject { first_paged_request }
 
-  it 'returns correct length from body' do
-    expect(subject.length).to eql(body.length)
-  end
-
-  it 'supports alias methods for length' do
-    expect(subject.count).to eql(subject.length)
-    expect(subject.size).to eql(subject.length)
-  end
-
-  it 'is Enumerable' do
-    expect(subject).to be_kind_of(Enumerable)
-  end
+  context '#items' do
+    it 'returns correct length from body' do
+      expect(subject.items.length).to eql(body.length)
+    end
 
-  it 'is iterable' do
-    expect(subject.map { |d| d }).to eql(body)
-  end
+    it 'is Enumerable' do
+      expect(subject.items).to be_kind_of(Enumerable)
+    end
 
-  context '#each' do
-    it 'returns an enumerator' do
-      expect(subject.each).to be_a(Enumerator)
+    it 'is iterable' do
+      expect(subject.items.map { |d| d }).to eql(body)
     end
 
-    it 'yields each item' do
-      items = []
-      subject.each do |item|
-        items << item
+    context '#each' do
+      it 'returns an enumerator' do
+        expect(subject.items.each).to be_a(Enumerator)
+      end
+
+      it 'yields each item' do
+        items = []
+        subject.items.each do |item|
+          items << item
+        end
+        expect(items).to eq(body)
       end
-      expect(items).to eq(body)
     end
-  end
 
-  it 'provides [] accessor method' do
-    expect(subject[0][:id]).to eql(body[0][:id])
-    expect(subject[1][:id]).to eql(body[1][:id])
-    expect(subject[2]).to be_nil
-  end
+    it 'provides [] accessor method' do
+      expect(subject.items[0][:id]).to eql(body[0][:id])
+      expect(subject.items[1][:id]).to eql(body[1][:id])
+      expect(subject.items[2]).to be_nil
+    end
 
-  specify '#first gets the first item in page' do
-    expect(subject.first[:id]).to eql(body[0][:id])
-  end
+    specify '#first gets the first item in page' do
+      expect(subject.items.first[:id]).to eql(body[0][:id])
+    end
 
-  specify '#last gets the last item in page' do
-    expect(subject.last[:id]).to eql(body[1][:id])
-  end
+    specify '#last gets the last item in page' do
+      expect(subject.items.last[:id]).to eql(body[1][:id])
+    end
 
-  context 'with coercion', :api_private do
-    let(:paginated_resource_options) { { coerce_into: 'OpenStruct' } }
+    context 'with coercion', :api_private do
+      let(:paginated_resource_options) { { coerce_into: 'OpenStruct' } }
 
-    it 'returns coerced objects' do
-      expect(subject.first).to be_a(OpenStruct)
-      expect(subject.first.id).to eql(body.first[:id])
+      it 'returns coerced objects' do
+        expect(subject.items.first).to be_a(OpenStruct)
+        expect(subject.items.first.id).to eql(body.first[:id])
+      end
     end
   end
 
@@ -90,7 +87,7 @@ describe Ably::Models::PaginatedResource do
       }
     end
     let(:paged_client) do
-      instance_double('Ably::Rest::Client', logger: true).tap do |client|
+      instance_double('Ably::Rest::Client', logger: Ably::Models::NilLogger.new).tap do |client|
         allow(client).to receive(:get).and_return(http_response_page2)
       end
     end
@@ -116,15 +113,15 @@ describe Ably::Models::PaginatedResource do
       end
 
       it 'calls the block for each resource after retrieving the resources' do
-        expect(subject[0][:added_attribute_from_block]).to eql("id:#{body[0][:id]}")
+        expect(subject.items[0][:added_attribute_from_block]).to eql("id:#{body[0][:id]}")
       end
 
       it 'calls the block for each resource on second page after retrieving the resources' do
-        page_1_first_id = subject[0][:id]
-        next_page = subject.next_page
+        page_1_first_id = subject.items[0][:id]
+        next_page = subject.next
 
-        expect(next_page[0][:added_attribute_from_block]).to eql("id:#{body_page2[0][:id]}")
-        expect(next_page[0][:id]).to_not eql(page_1_first_id)
+        expect(next_page.items[0][:added_attribute_from_block]).to eql("id:#{body_page2[0][:id]}")
+        expect(next_page.items[0][:id]).to_not eql(page_1_first_id)
       end
     end
 
@@ -136,17 +133,17 @@ describe Ably::Models::PaginatedResource do
           paginated_resource_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
         end
 
-        context '#next_page' do
+        context '#next' do
           it 'returns a SafeDeferrable that catches exceptions in callbacks and logs them' do
             run_reactor do
-              expect(subject.next_page).to be_a(Ably::Util::SafeDeferrable)
+              expect(subject.next).to be_a(Ably::Util::SafeDeferrable)
               stop_reactor
             end
           end
 
           it 'allows a success callback block to be added' do
             run_reactor do
-              subject.next_page do |paginated_resource|
+              subject.next do |paginated_resource|
                 expect(paginated_resource).to be_a(Ably::Models::PaginatedResource)
                 stop_reactor
               end
@@ -154,11 +151,11 @@ describe Ably::Models::PaginatedResource do
           end
         end
 
-        context '#first_page' do
+        context '#first' do
           it 'calls the errback callback when first page headers are missing' do
             run_reactor do
-              subject.next_page do |paginated_resource|
-                deferrable = subject.first_page
+              subject.next do |paginated_resource|
+                deferrable = subject.first
                 deferrable.errback do |error|
                   expect(error).to be_a(Ably::Exceptions::InvalidPageError)
                   stop_reactor
@@ -173,23 +170,27 @@ describe Ably::Models::PaginatedResource do
 
   context 'with non paged http response' do
     it 'is the first page' do
-      expect(subject).to be_first_page
+      expect(subject).to be_first
     end
 
     it 'is the last page' do
-      expect(subject).to be_last_page
+      expect(subject).to be_last
+    end
+
+    it 'does not have next page' do
+      expect(subject).to_not have_next
     end
 
     it 'does not support pagination' do
       expect(subject.supports_pagination?).to_not eql(true)
     end
 
-    it 'raises an exception when accessing next page' do
-      expect { subject.next_page }.to raise_error Ably::Exceptions::InvalidPageError, /Paging header link next/
+    it 'returns nil when accessing next page' do
+      expect(subject.next).to be_nil
     end
 
-    it 'raises an exception when accessing first page' do
-      expect { subject.first_page }.to raise_error Ably::Exceptions::InvalidPageError, /Paging header link first/
+    it 'returns nil when accessing first page' do
+      expect(subject.first).to be_nil
     end
   end
 
@@ -207,11 +208,15 @@ describe Ably::Models::PaginatedResource do
     end
 
     it 'is the first page' do
-      expect(subject).to be_first_page
+      expect(subject).to be_first
+    end
+
+    it 'has next page' do
+      expect(subject).to have_next
     end
 
     it 'is not the last page' do
-      expect(subject).to_not be_last_page
+      expect(subject).to_not be_last
     end
 
     it 'supports pagination' do
@@ -236,7 +241,7 @@ describe Ably::Models::PaginatedResource do
           headers: next_headers
         })
       end
-      let(:subject) { first_paged_request.next_page }
+      let(:subject) { first_paged_request.next }
 
       before do
         expect(client).to receive(:get).with("#{base_url}/history?index=1").and_return(next_http_response).once
@@ -247,39 +252,43 @@ describe Ably::Models::PaginatedResource do
       end
 
       it 'retrieves the next page of results' do
-        expect(subject.length).to eql(next_body.length)
-        expect(subject[0][:id]).to eql(next_body[0][:id])
+        expect(subject.items.length).to eql(next_body.length)
+        expect(subject.items[0][:id]).to eql(next_body[0][:id])
       end
 
       it 'is not the first page' do
-        expect(subject).to_not be_first_page
+        expect(subject).to_not be_first
+      end
+
+      it 'does not have a next page' do
+        expect(subject).to_not have_next
       end
 
       it 'is the last page' do
-        expect(subject).to be_last_page
+        expect(subject).to be_last
       end
 
-      it 'raises an exception if trying to access the last page when it is the last page' do
-        expect(subject).to be_last_page
-        expect { subject.next_page }.to raise_error Ably::Exceptions::InvalidPageError, /There are no more pages/
+      it 'returns nil when trying to access the last page when it is the last page' do
+        expect(subject).to be_last
+        expect(subject.next).to be_nil
       end
 
       context 'and then first page' do
         before do
           expect(client).to receive(:get).with("#{base_url}/history?index=0").and_return(http_response).once
         end
-        subject { first_paged_request.next_page.first_page }
+        subject { first_paged_request.next.first }
 
         it 'returns a PaginatedResource' do
           expect(subject).to be_a(paginated_resource_class)
         end
 
         it 'retrieves the first page of results' do
-          expect(subject.length).to eql(body.length)
+          expect(subject.items.length).to eql(body.length)
         end
 
         it 'is the first page' do
-          expect(subject).to be_first_page
+          expect(subject).to be_first
         end
       end
     end

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

@@ -0,0 +1,289 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+
+describe Ably::Models::Stats do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::Stats }
+
+  %w(all persisted).each do |attribute|
+    context "##{attribute} stats" do
+      let(:data) do
+        { attribute.to_sym => { messages: { count: 5 }, all: { data: 10 } } }
+      end
+      subject { Ably::Models::Stats.new(data.merge(interval_id: '2004-02')).public_send(attribute) }
+
+      it 'returns a MessageTypes object' do
+        expect(subject).to be_a(Ably::Models::Stats::MessageTypes)
+      end
+
+      it 'returns value for message counts' do
+        expect(subject.messages.count).to eql(5)
+      end
+
+      it 'returns value for all data transferred' do
+        expect(subject.all.data).to eql(10)
+      end
+
+      it 'returns zero for empty values' do
+        expect(subject.presence.count).to eql(0)
+      end
+
+      it 'raises an exception for unknown attributes' do
+        expect { subject.unknown }.to raise_error NoMethodError
+      end
+
+      %w(all presence messages).each do |type|
+        context "##{type}" do
+          it 'is a MessageCount object' do
+            expect(subject.public_send(type)).to be_a(Ably::Models::Stats::MessageCount)
+          end
+        end
+      end
+    end
+  end
+
+  %w(inbound outbound).each do |direction|
+    context "##{direction} stats" do
+      let(:data) do
+        {
+          direction.to_sym => {
+            realtime: { messages: { count: 5 }, presence: { data: 10 } },
+            all: { messages: { count: 25 }, presence: { data: 210 } }
+          }
+        }
+      end
+      subject { Ably::Models::Stats.new(data.merge(interval_id: '2004-02')).public_send(direction) }
+
+      it 'returns a MessageTraffic object' do
+        expect(subject).to be_a(Ably::Models::Stats::MessageTraffic)
+      end
+
+      it 'returns value for realtime message counts' do
+        expect(subject.realtime.messages.count).to eql(5)
+      end
+
+      it 'returns value for all presence data' do
+        expect(subject.all.presence.data).to eql(210)
+      end
+
+      it 'raises an exception for unknown attributes' do
+        expect { subject.unknown }.to raise_error NoMethodError
+      end
+
+      %w(realtime rest webhook all).each do |type|
+        context "##{type}" do
+          it 'is a MessageTypes object' do
+            expect(subject.public_send(type)).to be_a(Ably::Models::Stats::MessageTypes)
+          end
+        end
+      end
+    end
+  end
+
+  context '#connections stats' do
+    let(:data) do
+      { connections: { tls: { opened: 5 }, all: { peak: 10 } } }
+    end
+    subject { Ably::Models::Stats.new(data.merge(interval_id: '2004-02')).connections }
+
+    it 'returns a ConnectionTypes object' do
+      expect(subject).to be_a(Ably::Models::Stats::ConnectionTypes)
+    end
+
+    it 'returns value for tls opened counts' do
+      expect(subject.tls.opened).to eql(5)
+    end
+
+    it 'returns value for all peak connections' do
+      expect(subject.all.peak).to eql(10)
+    end
+
+    it 'returns zero for empty values' do
+      expect(subject.all.refused).to eql(0)
+    end
+
+    it 'raises an exception for unknown attributes' do
+      expect { subject.unknown }.to raise_error NoMethodError
+    end
+
+    %w(tls plain all).each do |type|
+      context "##{type}" do
+        it 'is a ResourceCount object' do
+          expect(subject.public_send(type)).to be_a(Ably::Models::Stats::ResourceCount)
+        end
+      end
+    end
+  end
+
+  context '#channels stats' do
+    let(:data) do
+      { channels: { opened: 5, peak: 10 } }
+    end
+    subject { Ably::Models::Stats.new(data.merge(interval_id: '2004-02')).channels }
+
+    it 'returns a ResourceCount object' do
+      expect(subject).to be_a(Ably::Models::Stats::ResourceCount)
+    end
+
+    it 'returns value for opened counts' do
+      expect(subject.opened).to eql(5)
+    end
+
+    it 'returns value for peak channels' do
+      expect(subject.peak).to eql(10)
+    end
+
+    it 'returns zero for empty values' do
+      expect(subject.refused).to eql(0)
+    end
+
+    it 'raises an exception for unknown attributes' do
+      expect { subject.unknown }.to raise_error NoMethodError
+    end
+
+    %w(opened peak mean min refused).each do |type|
+      context "##{type}" do
+        it 'is a Integer object' do
+          expect(subject.public_send(type)).to be_a(Integer)
+        end
+      end
+    end
+  end
+
+  %w(api_requests token_requests).each do |request_type|
+    context "##{request_type} stats" do
+      let(:data) do
+        {
+          request_type.to_sym => { succeeded: 5, failed: 10 }
+        }
+      end
+      subject { Ably::Models::Stats.new(data.merge(interval_id: '2004-02')).public_send(request_type) }
+
+      it 'returns a RequestCount object' do
+        expect(subject).to be_a(Ably::Models::Stats::RequestCount)
+      end
+
+      it 'returns value for succeeded' do
+        expect(subject.succeeded).to eql(5)
+      end
+
+      it 'returns value for failed' do
+        expect(subject.failed).to eql(10)
+      end
+
+      it 'raises an exception for unknown attributes' do
+        expect { subject.unknown }.to raise_error NoMethodError
+      end
+
+      %w(succeeded failed refused).each do |type|
+        context "##{type}" do
+          it 'is a Integer object' do
+            expect(subject.public_send(type)).to be_a(Integer)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#interval_granularity' do
+    subject { Ably::Models::Stats.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::Stats.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.gm(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.gm(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.gm(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.gm(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