ably-rest 0.8.2 → 0.8.3

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

@@ -65,32 +65,32 @@ describe Ably::Rest::Channel, 'messages' do
       context 'Integer' do
         let(:data) { 1 }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end
 
       context 'Float' do
         let(:data) { 1.1 }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end
 
       context 'Boolean' do
         let(:data) { true }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end
 
       context 'False' do
         let(:data) { false }
 
-        it 'is raises an UnsupportedDataTypeError 40011 exception' do
-          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataTypeError)
+        it 'is raises an UnsupportedDataType 40011 exception' do
+          expect { channel.publish 'event', data }.to raise_error(Ably::Exceptions::UnsupportedDataType)
         end
       end
     end

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

@@ -39,10 +39,12 @@ describe Ably::Rest::Presence do
         let(:presence_page) { fixtures_channel.presence.get }
 
         it 'returns current members on the channel with their action set to :present' do
+          expect(presence_page).to be_a(Ably::Models::PaginatedResult)
           expect(presence_page.items.size).to eql(fixtures.count)
 
           non_encoded_fixtures.each do |fixture|
             presence_message = presence_page.items.find { |client| client.client_id == fixture[:client_id] }
+            expect(presence_message).to be_a(Ably::Models::PresenceMessage)
             expect(presence_message.data).to eq(fixture[:data])
             expect(presence_message.action).to eq(:present)
           end
@@ -54,27 +56,87 @@ describe Ably::Rest::Presence do
 
           it 'returns a paged response limiting number of members per page' do
             expect(presence_page.items.size).to eql(page_size)
-            # TODO: To be enabled once Realtime Presence issue #164 is resolved
-            # expect(presence_page).to be_first
             next_page = presence_page.next
             expect(next_page.items.size).to eql(page_size)
             expect(next_page).to be_last
           end
         end
+
+        context 'default :limit', webmock: true do
+          let(:query_options) do
+            {
+              limit: 100
+            }
+          end
+          let(:endpoint) do
+            client.endpoint.tap do |client_end_point|
+              client_end_point.user = key_name
+              client_end_point.password = key_secret
+            end
+          end
+          let!(:get_stub) {
+            query_params = query_options.map { |k, v| "#{k}=#{v}" }.join('&')
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence?#{query_params}").
+              to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+          }
+          let(:channel_name) { random_str }
+          let(:channel)      { client.channels.get(channel_name) }
+
+          before do
+            channel.presence.get
+          end
+
+          it 'defaults to a limit of 100' do
+            expect(get_stub).to have_been_requested
+          end
+        end
+
+        context 'with :client_id option' do
+          let(:client_id) { non_encoded_fixtures.first[:client_id] }
+          let(:presence_page)  { fixtures_channel.presence.get(client_id: client_id) }
+
+          it 'returns a list members filtered by the provided client ID' do
+            pending 'not implemented in the REST API yet' # TODO realtime/issues/243
+            expect(presence_page.items.count).to eql(1)
+            expect(presence_page.items.first.client_id).to eql(client_id)
+          end
+        end
+
+        context 'with :connection_id option' do
+          let(:connection_id) { fixtures_channel.presence.get.first.connection_id }
+          let(:presence_page)  { fixtures_channel.presence.get(connection_id: connection_id) }
+
+          it 'returns a list members filtered by the provided connection ID' do
+            pending 'not implemented in the REST API yet' # TODO realtime/issues/243
+            expect(presence_page.items.count).to eql(1)
+            expect(presence_page.items.first.connetion_id).to eql(connetion_id)
+          end
+        end
       end
 
       describe '#history' do
         let(:history_page) { fixtures_channel.presence.history }
 
         it 'returns recent presence activity' do
+          expect(history_page).to be_a(Ably::Models::PaginatedResult)
           expect(history_page.items.size).to eql(fixtures.count)
 
           non_encoded_fixtures.each do |fixture|
             presence_message = history_page.items.find { |client| client.client_id == fixture['clientId'] }
+            expect(presence_message).to be_a(Ably::Models::PresenceMessage)
             expect(presence_message.data).to eq(fixture[:data])
           end
         end
 
+        context 'default behaviour' do
+          let(:default_page)   { fixtures_channel.presence.history }
+          let(:backwards_page) { fixtures_channel.presence.history(direction: :backwards) }
+
+          it 'uses backwards direction' do
+            expect(default_page.items).to eq(backwards_page.items)
+          end
+        end
+
         context 'with options' do
           let(:page_size) { 3 }
 
@@ -112,7 +174,7 @@ describe Ably::Rest::Presence do
     end
 
     describe '#history' do
-      context 'with time range options' do
+      context 'with options' do
         let(:channel_name) { "persisted:#{random_str(4)}" }
         let(:presence) { client.channel(channel_name).presence }
         let(:user) { 'appid.keyuid' }
@@ -126,44 +188,93 @@ describe Ably::Rest::Presence do
         let(:client) do
           Ably::Rest::Client.new(key: "#{user}:#{secret}")
         end
-        let(:default_options) do
+        let(:history_options) do
           {
             direction: :backwards,
             limit: 100
           }
         end
 
-        [:start, :end].each do |option|
-          describe ":#{option}", :webmock do
-            let!(:history_stub) {
-              query_params = default_options.merge(option => milliseconds).map { |k, v| "#{k}=#{v}" }.join('&')
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{query_params}").
-                to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
-            }
+        context 'limit options', :webmock do
+          let!(:history_stub) {
+            query_params = history_options.map { |k, v| "#{k}=#{v}" }.join('&')
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{query_params}").
+              to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+          }
 
-            before do
-              presence.history(options)
+          before do
+            presence.history(history_options)
+          end
+
+          context 'default' do
+            it 'is set to 100' do
+              expect(history_stub).to have_been_requested
             end
+          end
 
-            context 'with milliseconds since epoch value' do
-              let(:milliseconds) { as_since_epoch(Time.now) }
-              let(:options) { { option => milliseconds } }
+          context 'set to 1000' do
+            let(:history_options) do
+              {
+                direction: :backwards,
+                limit: 1000
+              }
+            end
 
-              it 'uses this value in the history request' do
-                expect(history_stub).to have_been_requested
-              end
+            it 'is passes the limit query param value 1000' do
+              expect(history_stub).to have_been_requested
             end
+          end
+        end
+
+        context 'with time range options' do
+          [:start, :end].each do |option|
+            describe ":#{option}", :webmock do
+              let(:history_options) {
+                {
+                  direction: :backwards,
+                  limit: 100,
+                  option => milliseconds
+                }
+              }
+              let!(:history_stub) {
+                query_params = history_options.map { |k, v| "#{k}=#{v}" }.join('&')
+                stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?#{query_params}").
+                  to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+              }
+
+              before do
+                presence.history(history_options)
+              end
+
+              context 'with milliseconds since epoch value' do
+                let(:milliseconds) { as_since_epoch(Time.now) }
+                let(:options) { { option => milliseconds } }
+
+                it 'uses this value in the history request' do
+                  expect(history_stub).to have_been_requested
+                end
+              end
 
-            context 'with Time object value' do
-              let(:time) { Time.now }
-              let(:milliseconds) { as_since_epoch(time) }
-              let(:options) { { option => time } }
+              context 'with Time object value' do
+                let(:time) { Time.now }
+                let(:milliseconds) { as_since_epoch(time) }
+                let(:options) { { option => time } }
 
-              it 'converts the value to milliseconds since epoch in the hisotry request' do
-                expect(history_stub).to have_been_requested
+                it 'converts the value to milliseconds since epoch in the hisotry request' do
+                  expect(history_stub).to have_been_requested
+                end
               end
             end
           end
+
+          context 'when argument start is after end' do
+            let(:presence) { client.channel(random_str).presence }
+            let(:subject) { presence.history(start: as_since_epoch(Time.now), end: Time.now - 120) }
+
+            it 'should raise an exception' do
+              expect { subject.items }.to raise_error ArgumentError
+            end
+          end
         end
       end
     end

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

@@ -7,6 +7,11 @@ describe Ably::Rest::Client, '#stats' do
   LAST_YEAR = Time.now.year - 1
   LAST_INTERVAL = Time.new(LAST_YEAR, 2, 3, 15, 5, 0) # 3rd Feb 20(x) 16:05:00
 
+  # Ensure metrics in previous year do not impact on tests for last year
+  PREVIOUS_YEAR = Time.now.year - 2
+  PREVIOUS_INTERVAL = Time.new(PREVIOUS_YEAR, 2, 3, 15, 5, 0)
+  PREVIOUS_YEAR_STATS = 120
+
   STATS_FIXTURES = [
     {
       intervalId: Ably::Models::Stats.to_interval_id(LAST_INTERVAL - 120, :minute),
@@ -30,19 +35,39 @@ describe Ably::Rest::Client, '#stats' do
     }
   ]
 
+  PREVIOUS_YEAR_STATS_FIXTURES = PREVIOUS_YEAR_STATS.times.map do |index|
+    {
+      intervalId: Ably::Models::Stats.to_interval_id(PREVIOUS_INTERVAL - (index * 60), :minute),
+      inbound:       { realtime: { messages: { count: index } } }
+    }
+  end
+
   before(:context) do
     reload_test_app # ensure no previous stats interfere
-    TestApp.instance.create_test_stats(STATS_FIXTURES)
+    TestApp.instance.create_test_stats(STATS_FIXTURES + PREVIOUS_YEAR_STATS_FIXTURES)
   end
 
   vary_by_protocol do
     let(:client) {  Ably::Rest::Client.new(key: api_key, environment: environment, protocol: protocol) }
 
     describe 'fetching application stats' do
+      it 'returns a PaginatedResult object' do
+        expect(client.stats).to be_kind_of(Ably::Models::PaginatedResult)
+      end
+
       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 no options' do
+          let(:subject) { client.stats(end: LAST_INTERVAL) } # end is needed to ensure no other tests have effected the stats
+          let(:stat)    { subject.items.first }
+
+          it 'uses the minute interval by default' do
+            expect(stat.interval_granularity).to eq(:minute)
+          end
+        end
+
         context 'with :from set to last interval and :limit set to 1' do
           let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), end: LAST_INTERVAL, unit: :minute, limit: 1) }
           let(:stat)    { subject.items.first }
@@ -124,7 +149,6 @@ describe Ably::Rest::Client, '#stats' do
           end
 
           it 'returns 3 pages of stats' do
-            expect(subject).to be_first
             expect(subject).to_not be_last
             page3 = subject.next.next
             expect(page3).to be_last
@@ -133,7 +157,7 @@ describe Ably::Rest::Client, '#stats' do
         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), end: LAST_INTERVAL, unit: :minute, direction: :backwards, limit: 1) }
+          let(:subject)        { client.stats(end: LAST_INTERVAL, unit: :minute, direction: :backwards, limit: 1) }
           let(:stat)           { subject.items.first }
 
           it 'returns the 3rd interval stats first as stats are provided backwards from :end' do
@@ -141,12 +165,36 @@ describe Ably::Rest::Client, '#stats' do
           end
 
           it 'returns 3 pages of stats' do
-            expect(subject).to be_first
             expect(subject).to_not be_last
             page3 = subject.next.next
             expect(page3.items.first.inbound.realtime.all.count).to eql(first_inbound_realtime_count)
           end
         end
+
+        context 'with :end set to last interval and :limit set to 3 to ensure only last years stats are included' do
+          let(:subject) { client.stats(end: LAST_INTERVAL, unit: :minute, limit: 3) }
+          let(:stats)   { subject.items }
+
+          context 'the REST API' do
+            it 'defaults to direction :backwards' do
+              expect(stats.first.inbound.realtime.messages.count).to eql(70) # current minute
+              expect(stats.last.inbound.realtime.messages.count).to eql(50) # 2 minutes back
+            end
+          end
+        end
+
+        context 'with :end set to previous year interval' do
+          let(:subject) { client.stats(end: PREVIOUS_INTERVAL, unit: :minute) }
+          let(:stats)   { subject.items }
+
+          context 'the REST API' do
+            it 'defaults to 100 items for pagination' do
+              expect(stats.count).to eql(100)
+              next_page_of_stats = subject.next.items
+              expect(next_page_of_stats.count).to eql(PREVIOUS_YEAR_STATS - 100)
+            end
+          end
+        end
       end
 
       [:hour, :day, :month].each do |interval|
@@ -172,6 +220,14 @@ describe Ably::Rest::Client, '#stats' do
           end
         end
       end
+
+      context 'when argument start is after end' do
+        let(:subject) { client.stats(start: as_since_epoch(LAST_INTERVAL), end: LAST_INTERVAL - 120, unit: :minute) }
+
+        it 'should raise an exception' do
+          expect { subject.items }.to raise_error ArgumentError
+        end
+      end
     end
   end
 end

data/lib/submodules/ably-ruby/spec/shared/client_initializer_behaviour.rb

@@ -87,12 +87,16 @@ shared_examples 'a client initializer' do
       it 'connects to the Ably service' do
         expect { subject }.to_not raise_error
       end
+
+      it 'uses basic auth' do
+        expect(subject.auth).to be_using_basic_auth
+      end
     end
 
     context 'key_name and key_secret', api_private: true do
       let(:client_options) { { key_name: 'id', key_secret: 'secret' } }
 
-      it 'constructs an key' do
+      it 'constructs a key' do
         expect(subject.auth.key).to eql('id:secret')
       end
     end
@@ -111,6 +115,10 @@ shared_examples 'a client initializer' do
       it 'sets the key_secret' do
         expect(subject.auth.key_secret).to eql('secret')
       end
+
+      it 'uses basic auth' do
+        expect(subject.auth).to be_using_basic_auth
+      end
     end
 
     context 'with a string token key instead of options hash' do
@@ -137,6 +145,15 @@ shared_examples 'a client initializer' do
       end
     end
 
+    context 'with token_params' do
+      let(:client_options) { { token_params: { ttl: 777, client_id: 'john' }, token: 'token' } }
+
+      it 'configures the default token_params' do
+        expect(subject.auth.token_params.fetch(:ttl)).to eql(777)
+        expect(subject.auth.token_params.fetch(:client_id)).to eql('john')
+      end
+    end
+
     context 'endpoint' do
       it 'defaults to production' do
         expect(subject.endpoint.to_s).to eql("#{protocol}s://#{subdomain}.ably.io")
@@ -149,6 +166,40 @@ shared_examples 'a client initializer' do
           expect(subject.endpoint.to_s).to eql("#{protocol}s://sandbox-#{subdomain}.ably.io")
         end
       end
+
+      context 'with rest_host option' do
+        let(:client_options) { default_options.merge(rest_host: 'custom-rest.host.com') }
+
+        it 'uses an alternate endpoint for REST clients' do
+          skip 'does not apply as testing a Realtime client' unless rest?
+          expect(subject.endpoint.to_s).to eql("#{protocol}s://custom-rest.host.com")
+        end
+      end
+
+      context 'with realtime_host option' do
+        let(:client_options) { default_options.merge(realtime_host: 'custom-realtime.host.com') }
+
+        it 'uses an alternate endpoint for Realtime clients' do
+          skip 'does not apply as testing a REST client' if rest?
+          expect(subject.endpoint.to_s).to eql("#{protocol}s://custom-realtime.host.com")
+        end
+      end
+
+      context 'with port option and non-TLS connections' do
+        let(:client_options) { default_options.merge(port: 999, tls: false) }
+
+        it 'uses the custom port for non-TLS requests' do
+          expect(subject.endpoint.to_s).to include(":999")
+        end
+      end
+
+      context 'with tls_port option and a TLS connection' do
+        let(:client_options) { default_options.merge(tls_port: 666, tls: true) }
+
+        it 'uses the custom port for TLS requests' do
+          expect(subject.endpoint.to_s).to include(":666")
+        end
+      end
     end
 
     context 'tls' do
@@ -175,8 +226,8 @@ shared_examples 'a client initializer' 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)
+        it 'specifies Logger::WARN log level' do
+          expect(subject.logger.log_level).to eql(::Logger::WARN)
         end
       end