ably 0.6.2 → 0.7.0

data/spec/acceptance/rest/base_spec.rb

@@ -1,12 +1,8 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'securerandom'
 
-describe 'REST' do
-  let(:client) do
-    Ably::Rest::Client.new(api_key: api_key, environment: environment)
-  end
-
-  describe 'protocol' do
+describe Ably::Rest do
+  describe 'transport protocol' do
     include Ably::Modules::Conversions
 
     let(:client_options) { {} }
@@ -14,218 +10,154 @@ describe 'REST' do
       Ably::Rest::Client.new(client_options.merge(api_key: 'appid.keyuid:keysecret'))
     end
 
-    context 'transport' do
-      let(:now) { Time.now - 1000 }
-      let(:body_value) { [as_since_epoch(now)] }
+    let(:now) { Time.now - 1000 }
+    let(:body_value) { [as_since_epoch(now)] }
 
-      before do
-        stub_request(:get, "#{client.endpoint}/time").
-          with(:headers => { 'Accept' => mime }).
-          to_return(:status => 200, :body => request_body, :headers => { 'Content-Type' => mime })
-      end
+    before do
+      stub_request(:get, "#{client.endpoint}/time").
+        with(:headers => { 'Accept' => mime }).
+        to_return(:status => 200, :body => request_body, :headers => { 'Content-Type' => mime })
+    end
 
-      context 'when protocol is not defined it defaults to :msgpack' do
-        let(:client_options) { { } }
-        let(:mime) { 'application/x-msgpack' }
-        let(:request_body) { body_value.to_msgpack }
+    context 'when protocol is not defined it defaults to :msgpack' do
+      let(:client_options) { { } }
+      let(:mime) { 'application/x-msgpack' }
+      let(:request_body) { body_value.to_msgpack }
 
-        it 'uses MsgPack', webmock: true do
-          expect(client.protocol).to eql(:msgpack)
-          expect(client.time).to be_within(1).of(now)
-        end
+      it 'uses MsgPack', :webmock do
+        expect(client.protocol).to eql(:msgpack)
+        expect(client.time).to be_within(1).of(now)
       end
+    end
 
-      options = [
-          { protocol: :json },
-          { use_binary_protocol: false }
-        ].each do |client_option|
+    options = [
+        { protocol: :json },
+        { use_binary_protocol: false }
+      ].each do |client_option|
 
-        context "when option #{client_option} is used" do
-          let(:client_options) { client_option }
-          let(:mime) { 'application/json' }
-          let(:request_body) { body_value.to_json }
+      context "when option #{client_option} is used" do
+        let(:client_options) { client_option }
+        let(:mime) { 'application/json' }
+        let(:request_body) { body_value.to_json }
 
-          it 'uses JSON', webmock: true do
-            expect(client.protocol).to eql(:json)
-            expect(client.time).to be_within(1).of(now)
-          end
+        it 'uses JSON', :webmock do
+          expect(client.protocol).to eql(:json)
+          expect(client.time).to be_within(1).of(now)
         end
       end
+    end
 
-      options = [
-          { protocol: :json },
-          { use_binary_protocol: false }
-        ].each do |client_option|
+    options = [
+        { protocol: :msgpack },
+        { use_binary_protocol: true }
+      ].each do |client_option|
 
-        context "when option #{client_option} is used" do
-          let(:client_options) { { protocol: :msgpack } }
-          let(:mime) { 'application/x-msgpack' }
-          let(:request_body) { body_value.to_msgpack }
+      context "when option #{client_option} is used" do
+        let(:client_options) { client_option }
+        let(:mime) { 'application/x-msgpack' }
+        let(:request_body) { body_value.to_msgpack }
 
-          it 'uses MsgPack', webmock: true do
-            expect(client.protocol).to eql(:msgpack)
-            expect(client.time).to be_within(1).of(now)
-          end
+        it 'uses MsgPack', :webmock do
+          expect(client.protocol).to eql(:msgpack)
+          expect(client.time).to be_within(1).of(now)
         end
       end
     end
   end
 
-  describe 'invalid requests in middleware' do
-    it 'should raise an InvalidRequest exception with a valid message' do
-      invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret', environment: environment)
-      expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
-        expect(error).to be_a(Ably::Exceptions::InvalidToken)
-        expect(error.message).to match(/invalid credentials/)
-        expect(error.code).to eql(40100)
-        expect(error.status).to eql(401)
-      end
-    end
-
-    describe 'server error with JSON response', webmock: true do
-      let(:error_response) { '{ "error": { "statusCode": 500, "code": 50000, "message": "Internal error" } }' }
-
-      before do
-        stub_request(:get, "#{client.endpoint}/time").
-          to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
-      end
-
-      it 'should raise a ServerError exception' do
-        expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Internal error/)
-      end
-    end
-
-    describe 'server error', webmock: true do
-      before do
-        stub_request(:get, "#{client.endpoint}/time").
-        to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
-      end
-
-      it 'should raise a ServerError exception' do
-        expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Unknown/)
-      end
+  vary_by_protocol do
+    let(:client) do
+      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
     end
-  end
-
-  describe 'authentication failure', webmock: true do
-    let(:token_1) { { id: SecureRandom.hex } }
-    let(:token_2) { { id: SecureRandom.hex } }
-    let(:channel) { 'channelname' }
 
-    before do
-      @token_requests = 0
-      @publish_attempts = 0
-
-      stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").to_return do
-        @token_requests += 1
-        {
-          :body => { access_token: send("token_#{@token_requests}").merge(expires: Time.now.to_i + 3600) }.to_json,
-          :headers => { 'Content-Type' => 'application/json' }
-        }
-      end
-
-      stub_request(:post, "#{client.endpoint}/channels/#{channel}/publish").to_return do
-        @publish_attempts += 1
-        if [1, 3].include?(@publish_attempts)
-          { status: 201, :body => '[]', :headers => { 'Content-Type' => 'application/json' } }
-        else
-          raise Ably::Exceptions::InvalidRequest.new('Authentication failure', 401, 40140)
+    describe 'failed requests' do
+      context 'due to invalid Auth' do
+        it 'should raise an InvalidRequest exception with a valid error message and code' do
+          invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret', environment: environment)
+          expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
+            expect(error).to be_a(Ably::Exceptions::InvalidRequest)
+            expect(error.message).to match(/invalid credentials/)
+            expect(error.code).to eql(40100)
+            expect(error.status).to eql(401)
+          end
         end
       end
-    end
-
-    context 'when auth#token_renewable?' do
-      before do
-        client.auth.authorise
-      end
-
-      it 'should automatically reissue a token' do
-        client.channel(channel).publish('evt', 'msg')
-        expect(@publish_attempts).to eql(1)
-
-        client.channel(channel).publish('evt', 'msg')
-        expect(@publish_attempts).to eql(3)
-        expect(@token_requests).to eql(2)
-      end
-    end
 
-    context 'when NOT auth#token_renewable?' do
-      let(:client) { Ably::Rest::Client.new(token_id: 'token ID cannot be used to create a new token', environment: environment) }
-      it 'should raise the exception' do
-        client.channel(channel).publish('evt', 'msg')
-        expect(@publish_attempts).to eql(1)
-        expect { client.channel(channel).publish('evt', 'msg') }.to raise_error Ably::Exceptions::InvalidToken
-        expect(@token_requests).to eql(0)
-      end
-    end
-  end
+      describe 'server error with JSON error response body', :webmock do
+        let(:error_response) { '{ "error": { "statusCode": 500, "code": 50000, "message": "Internal error" } }' }
 
-  describe Ably::Rest::Client do
-    context '#initialize' do
-      context 'with an auth block' do
-        let(:client) { Ably::Rest::Client.new(environment: environment) { token_request } }
-        let(:token_request) { client.auth.create_token_request(key_id: key_id, key_secret: key_secret, client_id: client_id) }
-        let(:client_id) { 'unique_client_id' }
+        before do
+          stub_request(:get, "#{client.endpoint}/time").
+            to_return(:status => 500, :body => error_response, :headers => { 'Content-Type' => 'application/json' })
+        end
 
-        it 'calls the block to get a new token' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(client_id)
+        it 'should raise a ServerError exception' do
+          expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Internal error/)
         end
       end
 
-      context 'with an auth URL' do
-        let(:client) { Ably::Rest::Client.new(environment: environment, auth_url: token_request_url, auth_method: :get) }
-        let(:token_request_url) { 'http://get.token.request.com/' }
-        let(:token_request) { client.auth.create_token_request(key_id: key_id, key_secret: key_secret, client_id: client_id) }
-        let(:client_id) { 'unique_client_id' }
-
+      describe '500 server error without a valid JSON response body', :webmock do
         before do
-          allow(client.auth).to receive(:token_request_from_auth_url).with(token_request_url, :auth_method => :get).and_return(token_request)
+          stub_request(:get, "#{client.endpoint}/time").
+          to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
         end
 
-        it 'sends an HTTP request to get a new token' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(client_id)
+        it 'should raise a ServerError exception' do
+          expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Unknown/)
         end
       end
     end
 
-    context 'token expiry' do
-      let(:client) do
-        Ably::Rest::Client.new(environment: environment) do
-          @request_index ||= 0
-          @request_index += 1
-          send("token_request_#{@request_index}")
+    describe 'token authentication failures', :webmock do
+      let(:token_1) { { id: random_str } }
+      let(:token_2) { { id: random_str } }
+      let(:channel) { 'channelname' }
+
+      before do
+        @token_requests = 0
+        @publish_attempts = 0
+
+        stub_request(:post, "#{client.endpoint}/keys/#{key_id}/requestToken").to_return do
+          @token_requests += 1
+          {
+            :body => { access_token: send("token_#{@token_requests}").merge(expires: Time.now.to_i + 3600) }.to_json,
+            :headers => { 'Content-Type' => 'application/json' }
+          }
+        end
+
+        stub_request(:post, "#{client.endpoint}/channels/#{channel}/publish").to_return do
+          @publish_attempts += 1
+          if [1, 3].include?(@publish_attempts)
+            { status: 201, :body => '[]', :headers => { 'Content-Type' => 'application/json' } }
+          else
+            raise Ably::Exceptions::InvalidRequest.new('Authentication failure', 401, 40140)
+          end
         end
       end
-      let(:token_request_1) { client.auth.create_token_request(token_request_options.merge(client_id: SecureRandom.hex)) }
-      let(:token_request_2) { client.auth.create_token_request(token_request_options.merge(client_id: SecureRandom.hex)) }
-
-      context 'when expired' do
-        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: Ably::Models::Token::TOKEN_EXPIRY_BUFFER } }
 
-        it 'creates a new token automatically when the old token expires' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+      context 'when auth#token_renewable?' do
+        before do
+          client.auth.authorise
+        end
 
-          sleep 1
+        it 'should automatically reissue a token' do
+          client.channel(channel).publish('evt', 'msg')
+          expect(@publish_attempts).to eql(1)
 
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_2[:client_id])
+          client.channel(channel).publish('evt', 'msg')
+          expect(@publish_attempts).to eql(3)
+          expect(@token_requests).to eql(2)
         end
       end
 
-      context 'token authentication with long expiry token' do
-        let(:token_request_options) { { key_id: key_id, key_secret: key_secret, ttl: 3600 } }
-
-        it 'creates a new token automatically when the old token expires' do
-          expect { client.channel('channel_name').publish('event', 'message') }.to change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
-
-          sleep 1
+      context 'when NOT auth#token_renewable?' do
+        let(:client) { Ably::Rest::Client.new(token_id: 'token ID cannot be used to create a new token', environment: environment, protocol: protocol) }
 
-          expect { client.channel('channel_name').publish('event', 'message') }.to_not change { client.auth.current_token }
-          expect(client.auth.current_token.client_id).to eql(token_request_1[:client_id])
+        it 'should raise an InvalidToken exception' do
+          client.channel(channel).publish('evt', 'msg')
+          expect(@publish_attempts).to eql(1)
+          expect { client.channel(channel).publish('evt', 'msg') }.to raise_error Ably::Exceptions::InvalidToken
+          expect(@token_requests).to eql(0)
         end
       end
     end

data/spec/acceptance/rest/channel_spec.rb

@@ -1,130 +1,130 @@
+# encoding: utf-8
 require 'spec_helper'
-require 'securerandom'
 
 describe Ably::Rest::Channel do
   include Ably::Modules::Conversions
 
-  [: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
+  vary_by_protocol do
+    let(:client) do
+      Ably::Rest::Client.new(api_key: api_key, environment: environment, protocol: protocol)
+    end
 
-      describe 'publishing messages' do
-        let(:channel) { client.channel('test') }
-        let(:event)   { 'foo' }
-        let(:message) { 'woop!' }
+    describe '#publish' do
+      let(:channel) { client.channel('test') }
+      let(:event)   { 'foo' }
+      let(:message) { 'woop!' }
 
-        it 'should publish the message ok' do
-          expect(channel.publish(event, message)).to eql(true)
-        end
+      it 'should publish the message adn return true indicating success' do
+        expect(channel.publish(event, message)).to eql(true)
       end
+    end
 
-      describe 'fetching channel history' do
-        let(:channel) { client.channel("persisted:#{SecureRandom.hex(4)}") }
-        let(:expected_history) do
-          [
-            { :name => 'test1', :data => 'foo' },
-            { :name => 'test2', :data => 'bar' },
-            { :name => 'test3', :data => 'baz' }
-          ]
-        end
-        let!(:before_published) { client.time }
+    describe '#history' do
+      let(:channel) { client.channel("persisted:#{random_str(4)}") }
+      let(:expected_history) do
+        [
+          { :name => 'test1', :data => 'foo' },
+          { :name => 'test2', :data => 'bar' },
+          { :name => 'test3', :data => 'baz' }
+        ]
+      end
+      let!(:before_published) { client.time }
 
-        before(:each) do
-          expected_history.each do |message|
-            channel.publish(message[:name], message[:data]) || raise('Unable to publish message')
-          end
+      before(:each) do
+        expected_history.each do |message|
+          channel.publish(message[:name], message[:data]) || raise('Unable to publish message')
         end
+      end
 
-        it 'should return all the history for the channel' do
-          actual_history = channel.history
+      it 'should return the current message history for the channel' do
+        actual_history = channel.history
 
-          expect(actual_history.size).to eql(3)
+        expect(actual_history.size).to eql(3)
 
-          expected_history.each do |message|
-            message_name, message_data = message[:name], message[:data]
-            matching_message = actual_history.find { |message| message.name == message_name && message.data == message_data }
-            expect(matching_message).to be_a(Ably::Models::Message)
-          end
+        expected_history.each do |message|
+          message_name, message_data = message[:name], message[:data]
+          matching_message = actual_history.find { |message| message.name == message_name && message.data == message_data }
+          expect(matching_message).to be_a(Ably::Models::Message)
         end
+      end
 
-        context 'timestamps' do
-          it 'should be greater than the time before the messages were published' do
-            channel.history.each do |message|
-              expect(before_published.to_f).to be < message.timestamp.to_f
-            end
+      context 'message timestamps' do
+        it 'should all be after the messages were published' do
+          channel.history.each do |message|
+            expect(before_published.to_f).to be < message.timestamp.to_f
           end
         end
+      end
 
-        it 'should return messages with unique IDs' do
+      context 'message IDs' do
+        it 'should be unique' do
           message_ids = channel.history.map(&:id).compact
           expect(message_ids.count).to eql(3)
           expect(message_ids.uniq.count).to eql(3)
         end
+      end
 
-        it 'should return paged history' do
-          page_1 = channel.history(limit: 1)
-          page_2 = page_1.next_page
-          page_3 = page_2.next_page
+      it 'should return paged history using the PaginatedResource model' do
+        page_1 = channel.history(limit: 1)
+        page_2 = page_1.next_page
+        page_3 = page_2.next_page
 
-          all_items = [page_1[0].id, page_2[0].id, page_3[0].id]
-          expect(all_items.uniq).to eql(all_items)
+        all_items = [page_1[0].id, page_2[0].id, page_3[0].id]
+        expect(all_items.uniq).to eql(all_items)
 
-          expect(page_1.size).to eql(1)
-          expect(page_1).to_not be_last_page
-          expect(page_1).to be_first_page
+        expect(page_1.size).to eql(1)
+        expect(page_1).to_not be_last_page
+        expect(page_1).to be_first_page
 
-          # Page 2
-          expect(page_2.size).to eql(1)
-          expect(page_2).to_not be_last_page
-          expect(page_2).to_not be_first_page
+        # Page 2
+        expect(page_2.size).to eql(1)
+        expect(page_2).to_not be_last_page
+        expect(page_2).to_not be_first_page
 
-          # Page 3
-          expect(page_3.size).to eql(1)
-          expect(page_3).to be_last_page
-          expect(page_3).to_not be_first_page
-        end
+        # Page 3
+        expect(page_3.size).to eql(1)
+        expect(page_3).to be_last_page
+        expect(page_3).to_not be_first_page
       end
+    end
 
-      describe 'history options' do
-        let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
-        let(:channel) { client.channel(channel_name) }
-        let(:endpoint) do
-          client.endpoint.tap do |client_end_point|
-            client_end_point.user = key_id
-            client_end_point.password = key_secret
-          end
+    describe '#history option' do
+      let(:channel_name) { "persisted:#{random_str(4)}" }
+      let(:channel) { client.channel(channel_name) }
+      let(:endpoint) do
+        client.endpoint.tap do |client_end_point|
+          client_end_point.user = key_id
+          client_end_point.password = key_secret
         end
+      end
 
-        [:start, :end].each do |option|
-          describe ":#{option}", webmock: true do
-            let!(:history_stub) {
-              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?live=true&#{option}=#{milliseconds}").
-                to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
-            }
+      [:start, :end].each do |option|
+        describe ":#{option}", :webmock do
+          let!(:history_stub) {
+            stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/messages?#{option}=#{milliseconds}").
+              to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+          }
 
-            before do
-              channel.history(options)
-            end
+          before do
+            channel.history(options)
+          end
 
-            context 'with milliseconds since epoch' do
-              let(:milliseconds) { as_since_epoch(Time.now) }
-              let(:options) { { option => milliseconds } }
+          context 'with milliseconds since epoch value' do
+            let(:milliseconds) { as_since_epoch(Time.now) }
+            let(:options) { { option => milliseconds } }
 
-              specify 'are left unchanged' do
-                expect(history_stub).to have_been_requested
-              end
+            it 'uses this value in the history request' do
+              expect(history_stub).to have_been_requested
             end
+          end
 
-            context 'with Time' do
-              let(:time) { Time.now }
-              let(:milliseconds) { as_since_epoch(time) }
-              let(:options) { { option => time } }
+          context 'with a Time object value' do
+            let(:time) { Time.now }
+            let(:milliseconds) { as_since_epoch(time) }
+            let(:options) { { option => time } }
 
-              specify 'are left unchanged' do
-                expect(history_stub).to have_been_requested
-              end
+            it 'converts the value to milliseconds since epoch in the hisotry request' do
+              expect(history_stub).to have_been_requested
             end
           end
         end