ably-rest 0.7.1 → 0.7.3

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+require 'ably/models/message_encoders/utf8'
+
+describe Ably::Models::MessageEncoders::Utf8 do
+  let(:string_ascii)        { 'string'.encode(Encoding::ASCII_8BIT) }
+  let(:string_utf8)         { 'string'.encode(Encoding::UTF_8) }
+
+  let(:client)              { instance_double('Ably::Realtime::Client') }
+
+  subject { Ably::Models::MessageEncoders::Utf8.new(client) }
+
+  context '#decode' do
+    before do
+      subject.decode message, {}
+    end
+
+    context 'message with utf8 payload' do
+      let(:message) { { data: string_ascii, encoding: 'utf-8' } }
+
+      it 'sets the encoding' do
+        expect(message[:data]).to eq(string_utf8)
+        expect(message[:data].encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'strips the encoding' do
+        expect(message[:encoding]).to be_nil
+      end
+    end
+
+    context 'message with utf8 payload before other payloads' do
+      let(:message) { { data: string_utf8, encoding: 'json/utf-8' } }
+
+      it 'sets the encoding' do
+        expect(message[:data]).to eql(string_utf8)
+        expect(message[:data].encoding).to eql(Encoding::UTF_8)
+      end
+
+      it 'strips the encoding' do
+        expect(message[:encoding]).to eql('json')
+      end
+    end
+
+    context 'message with another payload' do
+      let(:message) { { data: string_ascii, encoding: 'json' } }
+
+      it 'leaves the message data intact' do
+        expect(message[:data]).to eql(string_ascii)
+      end
+
+      it 'leaves the encoding intact' do
+        expect(message[:encoding]).to eql('json')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,389 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'shared/model_behaviour'
+require 'base64'
+require 'msgpack'
+
+describe Ably::Models::Message do
+  include Ably::Modules::Conversions
+
+  subject { Ably::Models::Message }
+  let(:protocol_message_timestamp) { as_since_epoch(Time.now) }
+  let(:protocol_message) { Ably::Models::ProtocolMessage.new(action: 1, timestamp: protocol_message_timestamp) }
+
+  it_behaves_like 'a model', with_simple_attributes: %w(name client_id data encoding) do
+    let(:model_args) { [protocol_message] }
+  end
+
+  context '#timestamp' do
+    let(:model) { subject.new({}, protocol_message) }
+
+    it 'retrieves attribute :timestamp as Time object from ProtocolMessage' do
+      expect(model.timestamp).to be_a(Time)
+      expect(model.timestamp.to_i).to be_within(1).of(Time.now.to_i)
+    end
+  end
+
+  context '#connection_id attribute' do
+    let(:protocol_connection_id) { random_str }
+    let(:protocol_message) { Ably::Models::ProtocolMessage.new('connectionId' => protocol_connection_id, action: 1, timestamp: protocol_message_timestamp) }
+    let(:model_connection_id) { random_str }
+
+    context 'when this model has a connectionId attribute' do
+      context 'but no protocol message' do
+        let(:model) { subject.new('connectionId' => model_connection_id ) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+
+      context 'with a protocol message with a different connectionId' do
+        let(:model) { subject.new({ 'connectionId' => model_connection_id }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(model_connection_id)
+        end
+      end
+    end
+
+    context 'when this model has no connectionId attribute' do
+      context 'and no protocol message' do
+        let(:model) { subject.new({ }) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to be_nil
+        end
+      end
+
+      context 'with a protocol message with a connectionId' do
+        let(:model) { subject.new({ }, protocol_message) }
+
+        it 'uses the model value' do
+          expect(model.connection_id).to eql(protocol_connection_id)
+        end
+      end
+    end
+  end
+
+  context 'Java naming', :api_private do
+    let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+
+    it 'converts the attribute to ruby symbol naming convention' do
+      expect(model.client_id).to eql('joe')
+    end
+  end
+
+  context 'initialized with' do
+    %w(name client_id encoding).each do |attribute|
+      context ":#{attribute}" do
+        let(:encoded_value)   { value.encode(encoding) }
+        let(:value)           { random_str }
+        let(:options)         { { attribute.to_sym => encoded_value } }
+        let(:model)           { subject.new(options, protocol_message) }
+        let(:model_attribute) { model.public_send(attribute) }
+
+        context 'as UTF_8 string' do
+          let(:encoding) { Encoding::UTF_8 }
+
+          it 'is permitted' do
+            expect(model_attribute).to eql(encoded_value)
+          end
+
+          it 'remains as UTF-8' do
+            expect(model_attribute.encoding).to eql(encoding)
+          end
+        end
+
+        context 'as SHIFT_JIS string' do
+          let(:encoding) { Encoding::SHIFT_JIS }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as ASCII_8BIT string' do
+          let(:encoding) { Encoding::ASCII_8BIT }
+
+          it 'gets converted to UTF-8' do
+            expect(model_attribute.encoding).to eql(Encoding::UTF_8)
+          end
+
+          it 'is compatible with original encoding' do
+            expect(model_attribute.encode(encoding)).to eql(encoded_value)
+          end
+        end
+
+        context 'as Integer' do
+          let(:encoded_value) { 1 }
+
+          it 'raises an argument error' do
+            expect { model_attribute }.to raise_error ArgumentError, /must be a String/
+          end
+        end
+
+        context 'as Nil' do
+          let(:encoded_value) { nil }
+
+          it 'is permitted' do
+            expect(model_attribute).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  context '#to_json', :api_private do
+    let(:json_object) { JSON.parse(model.to_json) }
+
+    context 'with valid data' do
+      let(:model) { subject.new({ name: 'test', clientId: 'joe' }, protocol_message) }
+
+      it 'converts the attribute back to Java mixedCase notation using string keys' do
+        expect(json_object["clientId"]).to eql('joe')
+      end
+    end
+
+    context 'with invalid data' do
+      let(:model) { subject.new({ clientId: 'joe' }, protocol_message) }
+
+      it 'raises an exception' do
+        expect { model.to_json }.to raise_error RuntimeError, /cannot generate a valid Hash/
+      end
+    end
+
+    context 'with binary data' do
+      let(:data) { MessagePack.pack(random_str(32)) }
+      let(:model) { subject.new({ name: 'test', data: data }, protocol_message) }
+
+      it 'encodes as Base64 so that it can be converted to UTF-8 automatically by JSON#dump' do
+        expect(json_object["data"]).to eql(::Base64.encode64(data))
+      end
+
+      it 'adds Base64 encoding' do
+        expect(json_object["encoding"]).to eql('base64')
+      end
+    end
+  end
+
+  context 'from REST request with embedded fields', :api_private do
+    let(:id)                  { random_str }
+    let(:protocol_message_id) { random_str }
+    let(:message_time)        { Time.now + 60 }
+    let(:message_timestamp)   { as_since_epoch(message_time) }
+    let(:protocol_time)       { Time.now }
+    let(:protocol_timestamp)  { as_since_epoch(protocol_time) }
+
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new({
+        action: :message,
+        timestamp: protocol_timestamp,
+        id: protocol_message_id
+      })
+    end
+
+    context 'with protocol message' do
+      let(:model) { subject.new({ id: id, timestamp: message_timestamp }, protocol_message) }
+
+      specify '#id prefers embedded ID' do
+        expect(model.id).to eql(id)
+      end
+
+      specify '#timestamp prefers embedded timestamp' do
+        expect(model.timestamp.to_i).to be_within(1).of(message_time.to_i)
+      end
+    end
+
+    context 'without protocol message' do
+      let(:model) { subject.new(id: id, timestamp: message_timestamp) }
+
+      specify '#id uses embedded ID' do
+        expect(model.id).to eql(id)
+      end
+
+      specify '#timestamp uses embedded timestamp' do
+        expect(model.timestamp.to_i).to be_within(1).of(message_time.to_i)
+      end
+    end
+  end
+
+  context 'part of ProtocolMessage', :api_private do
+    let(:ably_time) { Time.now + 5 }
+    let(:message_serial) { random_int_str(1_000_000) }
+    let(:connection_id) { random_str }
+
+    let(:message_0_payload) do
+      {
+        'string_key' => 'string_value',
+        1 => 2,
+        true => false
+      }
+    end
+
+    let(:message_0_json) do
+      {
+        name: 'zero',
+        data: message_0_payload
+      }
+    end
+
+    let(:message_1_json) do
+      {
+        name: 'one',
+        data: 'simple string'
+      }
+    end
+
+    let(:protocol_message_id) { random_str }
+    let(:protocol_message) do
+      Ably::Models::ProtocolMessage.new({
+        action: :message,
+        timestamp: ably_time.to_i,
+        msg_serial: message_serial,
+        id: protocol_message_id,
+        messages: [
+          message_0_json, message_1_json
+        ]
+      })
+    end
+
+    let(:message_0) { protocol_message.messages.first }
+    let(:message_1) { protocol_message.messages.last }
+
+    it 'should generate a message ID from the index, serial and connection id' do
+      expect(message_0.id).to eql("#{protocol_message_id}:0")
+      expect(message_1.id).to eql("#{protocol_message_id}:1")
+    end
+
+    it 'should not modify the data payload' do
+      expect(message_0.data['string_key']).to eql('string_value')
+      expect(message_0.data[1]).to eql(2)
+      expect(message_0.data[true]).to eql(false)
+      expect(message_0.data).to eql(message_0_payload)
+
+      expect(message_1.data).to eql('simple string')
+    end
+
+    it 'should not allow changes to the payload' do
+      expect { message_0.data["test"] = true }.to raise_error RuntimeError, /can't modify frozen.*Hash/
+    end
+
+    context 'with identical message objects' do
+      let(:protocol_message) do
+        Ably::Models::ProtocolMessage.new({
+          action: :message,
+          timestamp: ably_time.to_i,
+          msg_serial: message_serial,
+          id: protocol_message_id,
+          messages: [
+            message_0_json, message_0_json, message_0_json
+          ]
+        })
+      end
+
+      it 'provide a unique ID:index' do
+        expect(protocol_message.messages.map(&:id).uniq.count).to eql(3)
+      end
+
+      it 'recognises the index based on the object ID as opposed to message payload' do
+        expect(protocol_message.messages.first.id).to match(/0$/)
+        expect(protocol_message.messages.last.id).to match(/2$/)
+      end
+    end
+  end
+
+  context 'Message conversion method', :api_private do
+    let(:json) { { name: 'test', data: 'conversion' } }
+
+    context 'with JSON' do
+      context 'without ProtocolMessage' do
+        subject { Ably::Models.Message(json) }
+
+        it 'returns a Message object' do
+          expect(subject).to be_a(Ably::Models::Message)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.name).to eql('test')
+        end
+
+        it 'raises an exception when accessing ProtocolMessage' do
+          expect { subject.protocol_message }.to raise_error RuntimeError
+        end
+
+        it 'has no ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(false)
+        end
+      end
+
+      context 'with ProtocolMessage' do
+        subject { Ably::Models.Message(json, protocol_message) }
+
+        it 'returns a Message object' do
+          expect(subject).to be_a(Ably::Models::Message)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.name).to eql('test')
+        end
+
+        it 'provides access to ProtocolMessage' do
+          expect(subject.protocol_message).to eql(protocol_message)
+        end
+
+        it 'has a ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(true)
+        end
+      end
+    end
+
+    context 'with another Message' do
+      let(:message) { Ably::Models::Message.new(json) }
+
+      context 'without ProtocolMessage' do
+        subject { Ably::Models.Message(message) }
+
+        it 'returns a Message object' do
+          expect(subject).to be_a(Ably::Models::Message)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.name).to eql('test')
+        end
+
+        it 'raises an exception when accessing ProtocolMessage' do
+          expect { subject.protocol_message }.to raise_error RuntimeError
+        end
+
+        it 'has no ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(false)
+        end
+      end
+
+      context 'with ProtocolMessage' do
+        subject { Ably::Models.Message(message, protocol_message) }
+
+        it 'returns a Message object' do
+          expect(subject).to be_a(Ably::Models::Message)
+        end
+
+        it 'initializes with the JSON' do
+          expect(subject.name).to eql('test')
+        end
+
+        it 'provides access to ProtocolMessage' do
+          expect(subject.protocol_message).to eql(protocol_message)
+        end
+
+        it 'has a ProtocolMessage' do
+          expect(subject.assigned_to_protocol_message?).to eql(true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,288 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Ably::Models::PaginatedResource do
+  let(:paginated_resource_class) { Ably::Models::PaginatedResource }
+  let(:headers) { Hash.new }
+  let(:client) do
+    instance_double('Ably::Rest::Client').tap do |client|
+      allow(client).to receive(:get).and_return(http_response)
+    end
+  end
+  let(:body) do
+    [
+      { id: 0 },
+      { id: 1 }
+    ]
+  end
+  let(:http_response) do
+    instance_double('Faraday::Response', {
+      body: body,
+      headers: headers
+    })
+  end
+  let(:base_url) { 'http://rest.ably.io/channels/channel_name' }
+  let(:full_url) { "#{base_url}/whatever?param=exists" }
+  let(:paginated_resource_options) { Hash.new }
+  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
+
+  it 'is iterable' do
+    expect(subject.map { |d| d }).to eql(body)
+  end
+
+  context '#each' do
+    it 'returns an enumerator' do
+      expect(subject.each).to be_a(Enumerator)
+    end
+
+    it 'yields each item' do
+      items = []
+      subject.each do |item|
+        items << item
+      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
+
+  specify '#first gets the first item in page' do
+    expect(subject.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
+
+  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])
+    end
+  end
+
+  context 'paged transformations', :api_private do
+    let(:headers) do
+      {
+        'link' => [
+          '<./history?index=1>; rel="next"'
+        ].join(', ')
+      }
+    end
+    let(:paged_client) do
+      instance_double('Ably::Rest::Client').tap do |client|
+        allow(client).to receive(:get).and_return(http_response_page2)
+      end
+    end
+    let(:body_page2) do
+      [
+        { id: 2 },
+        { id: 3 }
+      ]
+    end
+    let(:http_response_page2) do
+      instance_double('Faraday::Response', {
+        body: body_page2,
+        headers: headers
+      })
+    end
+
+    context 'with each block' do
+      subject do
+        paginated_resource_class.new(http_response, full_url, paged_client, paginated_resource_options) do |resource|
+          resource[:added_attribute_from_block] = "id:#{resource[:id]}"
+          resource
+        end
+      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]}")
+      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
+
+        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)
+      end
+    end
+
+    if defined?(Ably::Realtime)
+      context 'with option async_blocking_operations: true' do
+        include RSpec::EventMachine
+
+        subject do
+          paginated_resource_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
+        end
+
+        context '#next_page' do
+          it 'returns a deferrable object' do
+            run_reactor do
+              expect(subject.next_page).to be_a(EventMachine::Deferrable)
+              stop_reactor
+            end
+          end
+
+          it 'allows a success callback block to be added' do
+            run_reactor do
+              subject.next_page do |paginated_resource|
+                expect(paginated_resource).to be_a(Ably::Models::PaginatedResource)
+                stop_reactor
+              end
+            end
+          end
+        end
+
+        context '#first_page' 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
+                deferrable.errback do |error|
+                  expect(error).to be_a(Ably::Exceptions::InvalidPageError)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'with non paged http response' do
+    it 'is the first page' do
+      expect(subject).to be_first_page
+    end
+
+    it 'is the last page' do
+      expect(subject).to be_last_page
+    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/
+    end
+
+    it 'raises an exception when accessing first page' do
+      expect { subject.first_page }.to raise_error Ably::Exceptions::InvalidPageError, /Paging header link first/
+    end
+  end
+
+  context 'with paged http response' do
+    let(:base_url) { 'http://rest.ably.io/channels/channel_name' }
+    let(:full_url) { "#{base_url}/messages" }
+    let(:headers) do
+      {
+        'link' => [
+          '<./history?index=0>; rel="first"',
+          '<./history?index=0>; rel="current"',
+          '<./history?index=1>; rel="next"'
+        ].join(', ')
+      }
+    end
+
+    it 'is the first page' do
+      expect(subject).to be_first_page
+    end
+
+    it 'is not the last page' do
+      expect(subject).to_not be_last_page
+    end
+
+    it 'supports pagination' do
+      expect(subject.supports_pagination?).to eql(true)
+    end
+
+    context 'accessing next page' do
+      let(:next_body) do
+        [ { id: 2 } ]
+      end
+      let(:next_headers) do
+        {
+          'link' => [
+            '<./history?index=0>; rel="first"',
+            '<./history?index=1>; rel="current"'
+          ].join(', ')
+        }
+      end
+      let(:next_http_response) do
+        double('http_response', {
+          body: next_body,
+          headers: next_headers
+        })
+      end
+      let(:subject) { first_paged_request.next_page }
+
+      before do
+        expect(client).to receive(:get).with("#{base_url}/history?index=1").and_return(next_http_response).once
+      end
+
+      it 'returns another PaginatedResource' do
+        expect(subject).to be_a(paginated_resource_class)
+      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])
+      end
+
+      it 'is not the first page' do
+        expect(subject).to_not be_first_page
+      end
+
+      it 'is the last page' do
+        expect(subject).to be_last_page
+      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/
+      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 }
+
+        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)
+        end
+
+        it 'is the first page' do
+          expect(subject).to be_first_page
+        end
+      end
+    end
+  end
+end
+