ably 0.8.1 → 0.8.2

data/spec/acceptance/realtime/stats_spec.rb

@@ -7,9 +7,9 @@ describe Ably::Realtime::Client, '#stats', :event_machine do
     end
 
     describe 'fetching stats' do
-      it 'should return a PaginatedResource' do
+      it 'should return a PaginatedResult' do
         client.stats do |stats|
-          expect(stats).to be_a(Ably::Models::PaginatedResource)
+          expect(stats).to be_a(Ably::Models::PaginatedResult)
           stop_reactor
         end
       end

data/spec/acceptance/rest/channel_spec.rb

@@ -64,7 +64,7 @@ describe Ably::Rest::Channel do
         end
       end
 
-      it 'should return paged history using the PaginatedResource model' do
+      it 'should return paged history using the PaginatedResult model' do
         page_1 = channel.history(limit: 1)
         page_2 = page_1.next
         page_3 = page_2.next

data/spec/acceptance/rest/encoders_spec.rb

@@ -162,7 +162,7 @@ describe Ably::Models::MessageEncoders do
       context 'with binary data' do
         let(:published_data) { binary_data }
 
-        it 'applies cipher and base64 encoding and sets the encoding attribute to "utf-8/cipher+aes-128-cbc/base64"' do
+        it 'applies cipher and base64 encoding and sets the encoding attribute to "cipher+aes-128-cbc/base64"' do
           on_publish do |encoding, encoded_data|
             expect(encoding).to eql('cipher+aes-128-cbc/base64')
             expect(decrypted(encoded_data, base64: true)).to eql(published_data)

data/spec/acceptance/rest/message_spec.rb

@@ -10,7 +10,7 @@ describe Ably::Rest::Channel, 'messages' do
     let(:client_options)         { default_client_options }
     let(:client)                 { Ably::Rest::Client.new(client_options) }
     let(:other_client)           { Ably::Rest::Client.new(client_options) }
-    let(:channel)                { client.channel('test') }
+    let(:channel)                { client.channel(random_str) }
 
     context 'publishing with an ASCII_8BIT message name' do
       let(:message_name) { random_str.encode(Encoding::ASCII_8BIT) }
@@ -23,6 +23,78 @@ describe Ably::Rest::Channel, 'messages' do
       end
     end
 
+    context 'with supported data payload content type' do
+      context 'JSON Object (Hash)' do
+        let(:data) { { 'Hash' => 'true' } }
+
+        it 'is encoded and decoded to the same hash' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+
+      context 'JSON Array' do
+        let(:data) { [ nil, true, false, 55, 'string', { 'Hash' => true }, ['array'] ] }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+
+      context 'String' do
+        let(:data) { random_str }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+
+      context 'Binary' do
+        let(:data) { Base64.encode64(random_str) }
+
+        it 'is encoded and decoded to the same Array' do
+          channel.publish 'event', data
+          expect(channel.history.items.first.data).to eql(data)
+        end
+      end
+    end
+
+    context 'with unsupported data payload content type' 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)
+        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)
+        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)
+        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)
+        end
+      end
+    end
+
     describe 'encryption and encoding' do
       let(:channel_name)      { "persisted:#{random_str}" }
       let(:cipher_options)    { { key: random_str(32) } }

data/spec/acceptance/rest/presence_spec.rb

@@ -54,6 +54,8 @@ 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
@@ -81,7 +83,7 @@ describe Ably::Rest::Presence do
             let(:paged_history_forward) { fixtures_channel.presence.history(limit: page_size, direction: :forwards) }
 
             it 'returns recent presence activity forwards with most recent history last' do
-              expect(paged_history_forward).to be_a(Ably::Models::PaginatedResource)
+              expect(paged_history_forward).to be_a(Ably::Models::PaginatedResult)
               expect(paged_history_forward.items.size).to eql(page_size)
 
               next_page = paged_history_forward.next
@@ -96,7 +98,7 @@ describe Ably::Rest::Presence do
             let(:paged_history_backward) { fixtures_channel.presence.history(limit: page_size, direction: :backwards) }
 
             it 'returns recent presence activity backwards with most recent history first' do
-              expect(paged_history_backward).to be_a(Ably::Models::PaginatedResource)
+              expect(paged_history_backward).to be_a(Ably::Models::PaginatedResult)
               expect(paged_history_backward.items.size).to eql(page_size)
 
               next_page = paged_history_backward.next

data/spec/unit/models/{paginated_resource_spec.rb → paginated_result_spec.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
 require 'ostruct'
 
-describe Ably::Models::PaginatedResource do
-  let(:paginated_resource_class) { Ably::Models::PaginatedResource }
+describe Ably::Models::PaginatedResult do
+  let(:paginated_result_class) { Ably::Models::PaginatedResult }
   let(:headers) { Hash.new }
   let(:client) do
     instance_double('Ably::Rest::Client', logger: Ably::Models::NilLogger.new).tap do |client|
@@ -23,8 +23,8 @@ describe Ably::Models::PaginatedResource do
   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) }
+  let(:paginated_result_options) { Hash.new }
+  let(:first_paged_request) { paginated_result_class.new(http_response, full_url, client, paginated_result_options) }
   subject { first_paged_request }
 
   context '#items' do
@@ -69,7 +69,7 @@ describe Ably::Models::PaginatedResource do
     end
 
     context 'with coercion', :api_private do
-      let(:paginated_resource_options) { { coerce_into: 'OpenStruct' } }
+      let(:paginated_result_options) { { coerce_into: 'OpenStruct' } }
 
       it 'returns coerced objects' do
         expect(subject.items.first).to be_a(OpenStruct)
@@ -106,17 +106,17 @@ describe Ably::Models::PaginatedResource do
 
     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
+        paginated_result_class.new(http_response, full_url, paged_client, paginated_result_options) do |result|
+          result[:added_attribute_from_block] = "id:#{result[:id]}"
+          result
         end
       end
 
-      it 'calls the block for each resource after retrieving the resources' do
+      it 'calls the block for each result after retrieving the results' do
         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
+      it 'calls the block for each result on second page after retrieving the results' do
         page_1_first_id = subject.items[0][:id]
         next_page = subject.next
 
@@ -130,7 +130,7 @@ describe Ably::Models::PaginatedResource do
         include RSpec::EventMachine
 
         subject do
-          paginated_resource_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
+          paginated_result_class.new(http_response, full_url, paged_client, async_blocking_operations: true)
         end
 
         context '#next' do
@@ -143,8 +143,8 @@ describe Ably::Models::PaginatedResource do
 
           it 'allows a success callback block to be added' do
             run_reactor do
-              subject.next do |paginated_resource|
-                expect(paginated_resource).to be_a(Ably::Models::PaginatedResource)
+              subject.next do |paginated_result|
+                expect(paginated_result).to be_a(Ably::Models::PaginatedResult)
                 stop_reactor
               end
             end
@@ -154,7 +154,7 @@ describe Ably::Models::PaginatedResource do
         context '#first' do
           it 'calls the errback callback when first page headers are missing' do
             run_reactor do
-              subject.next do |paginated_resource|
+              subject.next do |paginated_result|
                 deferrable = subject.first
                 deferrable.errback do |error|
                   expect(error).to be_a(Ably::Exceptions::InvalidPageError)
@@ -247,8 +247,8 @@ describe Ably::Models::PaginatedResource 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)
+      it 'returns another PaginatedResult' do
+        expect(subject).to be_a(paginated_result_class)
       end
 
       it 'retrieves the next page of results' do
@@ -279,8 +279,8 @@ describe Ably::Models::PaginatedResource do
         end
         subject { first_paged_request.next.first }
 
-        it 'returns a PaginatedResource' do
-          expect(subject).to be_a(paginated_resource_class)
+        it 'returns a PaginatedResult' do
+          expect(subject).to be_a(paginated_result_class)
         end
 
         it 'retrieves the first page of results' do

data/spec/unit/modules/event_emitter_spec.rb

@@ -15,23 +15,23 @@ describe Ably::Modules::EventEmitter do
 
   subject { klass.new }
 
-  context '#trigger event fan out' do
+  context '#emit event fan out' do
     it 'should emit an event for any number of subscribers' do
       2.times do
         subject.on(:message) { |msg| obj.received_message msg }
       end
 
       expect(obj).to receive(:received_message).with(msg).twice
-      subject.trigger :message, msg
+      subject.emit :message, msg
     end
 
     it 'sends only messages to matching event names' do
       subject.on(:valid) { |msg| obj.received_message msg }
 
       expect(obj).to receive(:received_message).with(msg).once
-      subject.trigger :valid, msg
-      subject.trigger :ignored, msg
-      subject.trigger 'valid', msg
+      subject.emit :valid, msg
+      subject.emit :ignored, msg
+      subject.emit 'valid', msg
     end
 
     context 'with coercion', :api_private do
@@ -43,7 +43,7 @@ describe Ably::Modules::EventEmitter do
         subject.on('valid') { |msg| obj.received_message msg }
 
         expect(obj).to receive(:received_message).with(msg).once
-        subject.trigger :valid, msg
+        subject.emit :valid, msg
       end
     end
 
@@ -52,7 +52,7 @@ describe Ably::Modules::EventEmitter do
         subject.on('valid') { |msg| obj.received_message msg }
 
         expect(obj).to_not receive(:received_message).with(msg)
-        subject.trigger :valid, msg
+        subject.emit :valid, msg
       end
     end
 
@@ -62,8 +62,8 @@ describe Ably::Modules::EventEmitter do
 
         expect(obj).to receive(:received_message).with(msg).twice
 
-        subject.trigger :click, msg
-        subject.trigger :hover, msg
+        subject.emit :click, msg
+        subject.emit :hover, msg
       end
     end
 
@@ -84,17 +84,17 @@ describe Ably::Modules::EventEmitter do
         it 'is unaffected and processes the prior event callbacks once' do
           expect(obj).to receive(:received_message).with(msg).twice
           expect(obj).to_not receive(:received_message_from_new_callbacks).with(msg)
-          subject.trigger :message, msg
+          subject.emit :message, msg
         end
 
         it 'adds them for the next emitted event' do
           expect(obj).to receive(:received_message_from_new_callbacks).with(msg).twice
 
-          # New callbacks are added in this trigger
-          subject.trigger :message, msg
+          # New callbacks are added in this emit
+          subject.emit :message, msg
 
           # New callbacks are now called with second event emitted
-          subject.trigger :message, msg
+          subject.emit :message, msg
         end
       end
 
@@ -110,16 +110,16 @@ describe Ably::Modules::EventEmitter do
 
         it 'is unaffected and processes the prior event callbacks once' do
           expect(obj).to receive(:received_message).with(msg).twice
-          subject.trigger :message, msg
+          subject.emit :message, msg
         end
 
         it 'removes them for the next emitted event' do
           expect(obj).to receive(:received_message).with(msg).twice
 
-          # Callbacks are removed in this trigger
-          subject.trigger :message, msg
+          # Callbacks are removed in this emit
+          subject.emit :message, msg
           # No callbacks should exist now
-          subject.trigger :message, msg
+          subject.emit :message, msg
         end
       end
     end
@@ -129,14 +129,14 @@ describe Ably::Modules::EventEmitter do
     it 'calls the block every time an event is emitted only' do
       block_called = 0
       subject.on('event') { block_called += 1 }
-      3.times { subject.trigger 'event', 'data' }
+      3.times { subject.emit 'event', 'data' }
       expect(block_called).to eql(3)
     end
 
     it 'catches exceptions in the provided block, logs the error and continues' do
       expect(subject.logger).to receive(:error).with(/Intentional exception/)
       subject.on(:event) { raise 'Intentional exception' }
-      subject.trigger :event
+      subject.emit :event
     end
   end
 
@@ -144,13 +144,13 @@ describe Ably::Modules::EventEmitter do
     it 'calls the block every time an event is emitted only' do
       block_called = 0
       subject.unsafe_on('event') { block_called += 1 }
-      3.times { subject.trigger 'event', 'data' }
+      3.times { subject.emit 'event', 'data' }
       expect(block_called).to eql(3)
     end
 
     it 'does not catch exceptions in provided blocks' do
       subject.unsafe_on(:event) { raise 'Intentional exception' }
-      expect { subject.trigger :event }.to raise_error(/Intentional exception/)
+      expect { subject.emit :event }.to raise_error(/Intentional exception/)
     end
   end
 
@@ -158,7 +158,7 @@ describe Ably::Modules::EventEmitter do
     it 'calls the block the first time an event is emitted only' do
       block_called = 0
       subject.once('event') { block_called += 1 }
-      3.times { subject.trigger 'event', 'data' }
+      3.times { subject.emit 'event', 'data' }
       expect(block_called).to eql(1)
     end
 
@@ -166,14 +166,14 @@ describe Ably::Modules::EventEmitter do
       block_called = 0
       subject.once('event') { block_called += 1 }
       subject.on('event')   { block_called += 1 }
-      3.times { subject.trigger 'event', 'data' }
+      3.times { subject.emit 'event', 'data' }
       expect(block_called).to eql(4)
     end
 
     it 'catches exceptions in the provided block, logs the error and continues' do
       expect(subject.logger).to receive(:error).with(/Intentional exception/)
       subject.once(:event) { raise 'Intentional exception' }
-      subject.trigger :event
+      subject.emit :event
     end
   end
 
@@ -181,13 +181,13 @@ describe Ably::Modules::EventEmitter do
     it 'calls the block the first time an event is emitted only' do
       block_called = 0
       subject.unsafe_once('event') { block_called += 1 }
-      3.times { subject.trigger 'event', 'data' }
+      3.times { subject.emit 'event', 'data' }
       expect(block_called).to eql(1)
     end
 
     it 'does not catch exceptions in provided blocks' do
       subject.unsafe_once(:event) { raise 'Intentional exception' }
-      expect { subject.trigger :event }.to raise_error(/Intentional exception/)
+      expect { subject.emit :event }.to raise_error(/Intentional exception/)
     end
   end
 
@@ -199,7 +199,7 @@ describe Ably::Modules::EventEmitter do
     end
 
     after do
-      subject.trigger :message, msg
+      subject.emit :message, msg
     end
 
     context 'with event names as arguments' do

data/spec/unit/modules/state_emitter_spec.rb

@@ -41,7 +41,7 @@ describe Ably::Modules::StateEmitter do
     let(:args) { [5,3,1] }
     let(:callback_status) { { called: false } }
 
-    it 'passes the arguments through to the triggered callback' do
+    it 'passes the arguments through to the executed callback' do
       subject.on(:connecting) do |*callback_args|
         expect(callback_args).to eql(args)
         callback_status[:called] = true

data/spec/unit/realtime/channel_spec.rb

@@ -118,12 +118,12 @@ describe Ably::Realtime::Channel do
     specify 'are supported for valid STATE events' do
       state = nil
       subject.on(:initialized) { state = :ready }
-      expect { subject.trigger(:initialized) }.to change { state }.to(:ready)
+      expect { subject.emit(:initialized) }.to change { state }.to(:ready)
     end
 
     specify 'fail with unacceptable STATE event names' do
       expect { subject.on(:invalid) }.to raise_error KeyError
-      expect { subject.trigger(:invalid) }.to raise_error KeyError
+      expect { subject.emit(:invalid) }.to raise_error KeyError
       expect { subject.off(:invalid) }.to raise_error KeyError
     end
   end