ably 0.1.5 → 0.1.6

data/spec/acceptance/rest/base_spec.rb

@@ -14,8 +14,6 @@ describe "REST" do
       Ably::Rest::Client.new(client_options.merge(api_key: 'appid.keyuid:keysecret'))
     end
 
-    skip '#protocol should default to :msgpack'
-
     context 'transport' do
       let(:now) { Time.now - 1000 }
       let(:body_value) { [as_since_epoch(now)] }
@@ -26,22 +24,8 @@ describe "REST" do
           to_return(:status => 200, :body => request_body, :headers => { 'Content-Type' => mime })
       end
 
-      context 'when protocol is set as :json' do
-        let(:client_options) { { protocol: :json } }
-        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
-
-        skip 'uses JSON against Ably service for Auth'
-        skip 'uses JSON against Ably service for Messages'
-      end
-
-      context 'when protocol is set as :msgpack' do
-        let(:client_options) { { protocol: :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 }
 
@@ -49,9 +33,40 @@ describe "REST" 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|
+
+        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
+        end
+      end
+
+      options = [
+          { protocol: :json },
+          { use_binary_protocol: false }
+        ].each do |client_option|
 
-        skip 'uses MsgPack against Ably service for Auth'
-        skip 'uses MsgPack against Ably service for Messages'
+        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 }
+
+          it 'uses MsgPack', webmock: true do
+            expect(client.protocol).to eql(:msgpack)
+            expect(client.time).to be_within(1).of(now)
+          end
+        end
       end
     end
   end
@@ -60,7 +75,7 @@ describe "REST" 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::InvalidRequest)
+        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)
@@ -71,7 +86,8 @@ describe "REST" 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' })
+        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
@@ -81,7 +97,8 @@ describe "REST" do
 
     describe "server error", webmock: true do
       before do
-        stub_request(:get, "#{client.endpoint}/time").to_return(:status => 500)
+        stub_request(:get, "#{client.endpoint}/time").
+        to_return(:status => 500, :headers => { 'Content-Type' => 'application/json' })
       end
 
       it "should raise a ServerError exception" do
@@ -110,9 +127,9 @@ describe "REST" do
       stub_request(:post, "#{client.endpoint}/channels/#{channel}/publish").to_return do
         @publish_attempts += 1
         if [1, 3].include?(@publish_attempts)
-          { status: 201, :body => '[]' }
+          { status: 201, :body => '[]', :headers => { 'Content-Type' => 'application/json' } }
         else
-          raise Ably::Exceptions::InvalidRequest.new('Authentication failure', status: 401, code: 40140)
+          raise Ably::Exceptions::InvalidRequest.new('Authentication failure', 401, 40140)
         end
       end
     end
@@ -185,7 +202,7 @@ describe "REST" do
       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::Token::TOKEN_EXPIRY_BUFFER } }
+        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 }

data/spec/acceptance/rest/channel_spec.rb

@@ -4,107 +4,112 @@ require "securerandom"
 describe "REST" do
   include Ably::Modules::Conversions
 
-  let(:client) do
-    Ably::Rest::Client.new(api_key: api_key, environment: environment)
-  end
-
-  describe "publishing messages" 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
-  end
+  [: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
 
-  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
+      describe "publishing messages" do
+        let(:channel) { client.channel("test") }
+        let(:event)   { "foo" }
+        let(:message) { "woop!" }
 
-    before(:each) do
-      expected_history.each do |message|
-        channel.publish(message[:name], message[:data]) || raise("Unable to publish message")
+        it "should publish the message ok" do
+          expect(channel.publish(event, message)).to eql(true)
+        end
       end
-    end
 
-    it "should return all the history for the channel" do
-      actual_history = channel.history
-
-      expect(actual_history.size).to eql(3)
+      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
 
-      expected_history.each do |message|
-        expect(actual_history).to include(Ably::Rest::Models::Message.new(message))
-        expect(actual_history.map(&:json)).to include(message)
-      end
-    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 paged history" do
-      page_1 = channel.history(limit: 1)
-      page_2 = page_1.next_page
-      page_3 = page_2.next_page
+        it "should return all the history for the channel" do
+          actual_history = channel.history
 
-      all_items = [page_1[0], page_2[0], page_3[0]]
-      expect(all_items.uniq).to eql(all_items)
+          expect(actual_history.size).to eql(3)
 
-      expect(page_1.size).to eql(1)
-      expect(page_1).to_not be_last_page
-      expect(page_1).to be_first_page
+          expected_history.each do |message|
+            expect(actual_history).to include(Ably::Models::Message.new(message))
+            expect(actual_history.map(&:hash)).to include(message)
+          end
+        end
 
-      # 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
+        it "should return paged history" do
+          page_1 = channel.history(limit: 1)
+          page_2 = page_1.next_page
+          page_3 = page_2.next_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
-  end
+          all_items = [page_1[0].id, page_2[0].id, page_3[0].id]
+          expect(all_items.uniq).to eql(all_items)
 
-  describe "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
-    end
+          expect(page_1.size).to eql(1)
+          expect(page_1).to_not be_last_page
+          expect(page_1).to be_first_page
 
-    [: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 => '{}')
-        }
+          # 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
 
-        before do
-          channel.history(options)
+          # 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
 
-        context 'with milliseconds since epoch' do
-          let(:milliseconds) { as_since_epoch(Time.now) }
-          let(:options) { { option => milliseconds } }
-
-          specify 'are left unchanged' do
-            expect(history_stub).to have_been_requested
+      describe "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
         end
 
-        context 'with Time' 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
+        [: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' })
+            }
+
+            before do
+              channel.history(options)
+            end
+
+            context 'with milliseconds since epoch' 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
+            end
+
+            context 'with Time' 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
+            end
           end
         end
       end

data/spec/acceptance/rest/channels_spec.rb

@@ -2,38 +2,42 @@ require "spec_helper"
 require "securerandom"
 
 describe Ably::Rest::Channels do
-  let(:client) do
-    Ably::Rest::Client.new(api_key: api_key, environment: environment)
-  end
-  let(:channel_name) { SecureRandom.hex }
-  let(:options) { { key: 'value' } }
+  [: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
+      let(:channel_name) { SecureRandom.hex }
+      let(:options) { { key: 'value' } }
 
-  shared_examples "a channel" do
-    it "should access a channel" do
-      expect(channel).to be_a Ably::Rest::Channel
-      expect(channel.name).to eql(channel_name)
-    end
+      shared_examples "a channel" do
+        it "should access a channel" do
+          expect(channel).to be_a Ably::Rest::Channel
+          expect(channel.name).to eql(channel_name)
+        end
 
-    it "should allow options to be set on a channel" do
-      expect(channel_with_options.options).to eql(options)
-    end
-  end
+        it "should allow options to be set on a channel" do
+          expect(channel_with_options.options).to eql(options)
+        end
+      end
 
-  describe "using shortcut method on client" do
-    let(:channel) { client.channel(channel_name) }
-    let(:channel_with_options) { client.channel(channel_name, options) }
-    it_behaves_like 'a channel'
-  end
+      describe "using shortcut method on client" do
+        let(:channel) { client.channel(channel_name) }
+        let(:channel_with_options) { client.channel(channel_name, options) }
+        it_behaves_like 'a channel'
+      end
 
-  describe "using documented .get method on client.channels" do
-    let(:channel) { client.channels.get(channel_name) }
-    let(:channel_with_options) { client.channels.get(channel_name, options) }
-    it_behaves_like 'a channel'
-  end
+      describe "using documented .get method on client.channels" do
+        let(:channel) { client.channels.get(channel_name) }
+        let(:channel_with_options) { client.channels.get(channel_name, options) }
+        it_behaves_like 'a channel'
+      end
 
-  describe "using undocumented [] method on client.channels" do
-    let(:channel) { client.channels[channel_name] }
-    let(:channel_with_options) { client.channels[channel_name, options] }
-    it_behaves_like 'a channel'
+      describe "using undocumented [] method on client.channels" do
+        let(:channel) { client.channels[channel_name] }
+        let(:channel_with_options) { client.channels[channel_name, options] }
+        it_behaves_like 'a channel'
+      end
+    end
   end
 end

data/spec/acceptance/rest/presence_spec.rb

@@ -4,85 +4,105 @@ require "securerandom"
 describe "REST" do
   include Ably::Modules::Conversions
 
-  let(:client) do
-    Ably::Rest::Client.new(api_key: api_key, environment: environment)
-  end
-
-  let(:fixtures) do
-    TestApp::APP_SPEC['channels'].first['presence'].map do |fixture|
-      IdiomaticRubyWrapper(fixture, stop_at: [:client_data])
-    end
-  end
-
-  describe "fetching presence" do
-    let(:channel) { client.channel("persisted:presence_fixtures") }
-    let(:presence) { channel.presence.get }
-
-    it "should return current members on the channel" do
-      expect(presence.size).to eql(4)
+  [: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
 
-      fixtures.each do |fixture|
-        presence_message = presence.find { |client| client[:client_id] == fixture[:client_id] }
-        expect(presence_message[:client_data]).to eq(fixture[:client_data])
+      let(:fixtures) do
+        TestApp::APP_SPEC['channels'].first['presence'].map do |fixture|
+          IdiomaticRubyWrapper(fixture, stop_at: [:client_data])
+        end
       end
-    end
-  end
 
-  describe "presence history" do
-    let(:channel) { client.channel("persisted:presence_fixtures") }
-    let(:history) { channel.presence.history }
+      describe "fetching presence" do
+        let(:channel) { client.channel("persisted:presence_fixtures") }
+        let(:presence) { channel.presence.get }
 
-    it "should return recent presence activity" do
-      expect(history.size).to eql(4)
+        it "returns current members on the channel" do
+          expect(presence.size).to eql(4)
 
-      fixtures.each do |fixture|
-        presence_message = history.find { |client| client[:client_id] == fixture['clientId'] }
-        expect(presence_message[:client_data]).to eq(fixture[:client_data])
+          fixtures.each do |fixture|
+            presence_message = presence.find { |client| client.client_id == fixture[:client_id] }
+            expect(presence_message.client_data).to eq(fixture[:client_data])
+          end
+        end
       end
-    end
-  end
 
-  describe "options" do
-    let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
-    let(:presence) { client.channel(channel_name).presence }
-    let(:user) { 'appid.keyuid' }
-    let(:secret) { SecureRandom.hex(8) }
-    let(:endpoint) do
-      client.endpoint.tap do |client_end_point|
-        client_end_point.user = user
-        client_end_point.password = secret
-      end
-    end
-    let(:client) do
-      Ably::Rest::Client.new(api_key: "#{user}:#{secret}")
-    end
+      describe "presence history" do
+        let(:channel) { client.channel("persisted:presence_fixtures") }
+        let(:history) { channel.presence.history }
 
-    [:start, :end].each do |option|
-      describe ":{option}", webmock: true do
-        let!(:history_stub) {
-          stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?live=true&#{option}=#{milliseconds}").to_return(:body => '{}')
-        }
+        it "returns recent presence activity" do
+          expect(history.size).to eql(4)
 
-        before do
-          presence.history(options)
+          fixtures.each do |fixture|
+            presence_message = history.find { |client| client.client_id == fixture['clientId'] }
+            expect(presence_message.client_data).to eq(fixture[:client_data])
+          end
         end
 
-        context 'with milliseconds since epoch' do
-          let(:milliseconds) { as_since_epoch(Time.now) }
-          let(:options) { { option => milliseconds } }
+        context 'with options' do
+          let(:page_size) { 2 }
+          let(:paged_history_forward) { channel.presence.history(limit: page_size, direction: :forwards) }
 
-          specify 'are left unchanged' do
-            expect(history_stub).to have_been_requested
+          it "returns recent presence activity with options passsed to Ably" do
+            expect(paged_history_forward).to be_a(Ably::Models::PaginatedResource)
+            expect(paged_history_forward.size).to eql(2)
+
+            next_page = paged_history_forward.next_page
+
+            expect(paged_history_forward.first.id).to eql(history.last.id)
+            expect(next_page.first.id).to eql(history[page_size].id)
           end
         end
+      end
 
-        context 'with Time' do
-          let(:time) { Time.now }
-          let(:milliseconds) { as_since_epoch(time) }
-          let(:options) { { option => time } }
+      describe "options" do
+        let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
+        let(:presence) { client.channel(channel_name).presence }
+        let(:user) { 'appid.keyuid' }
+        let(:secret) { SecureRandom.hex(8) }
+        let(:endpoint) do
+          client.endpoint.tap do |client_end_point|
+            client_end_point.user = user
+            client_end_point.password = secret
+          end
+        end
+        let(:client) do
+          Ably::Rest::Client.new(api_key: "#{user}:#{secret}")
+        end
 
-          specify 'are left unchanged' do
-            expect(history_stub).to have_been_requested
+        [:start, :end].each do |option|
+          describe ":{option}", webmock: true do
+            let!(:history_stub) {
+              stub_request(:get, "#{endpoint}/channels/#{CGI.escape(channel_name)}/presence/history?live=true&#{option}=#{milliseconds}").
+                to_return(:body => '{}', :headers => { 'Content-Type' => 'application/json' })
+            }
+
+            before do
+              presence.history(options)
+            end
+
+            context 'with milliseconds since epoch' 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
+            end
+
+            context 'with Time' 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
+            end
           end
         end
       end