ably 0.1.1 → 0.1.2

data/lib/ably/rest/models/message.rb

@@ -0,0 +1,62 @@
+module Ably::Rest::Models
+  # A Message object encapsulates an individual message published in Ably retrieved via Rest
+  class Message
+    def initialize(message)
+      @message = message.dup.freeze
+    end
+
+    # Event name
+    #
+    # @return [String]
+    def name
+      json[:name]
+    end
+
+    # Payload
+    #
+    # @return [Object]
+    def data
+      json[:data]
+    end
+
+    # Client ID of the publisher of the message
+    #
+    # @return [String]
+    def client_id
+      json[:client_id]
+    end
+
+    # Timestamp when message was sent.  This property is populated by the sender.
+    #
+    # @return [Time]
+    def sender_timestamp
+      Time.at(json[:timestamp] / 1000.0) if json[:timestamp]
+    end
+
+    # Unique message ID
+    #
+    # @return [String]
+    def message_id
+      json[:message_id]
+    end
+
+    # Provide a normal Hash accessor to the underlying raw message object
+    #
+    # @return [Object]
+    def [](key)
+      json[key]
+    end
+
+    # Raw message object
+    #
+    # @return [Hash]
+    def json
+      @message
+    end
+
+    def ==(other)
+      other.kind_of?(Message) &&
+        json == other.json
+    end
+  end
+end

data/lib/ably/rest/models/paged_resource.rb

@@ -0,0 +1,117 @@
+module Ably::Rest::Models
+  # Wraps any Ably HTTP response that supports paging and automatically provides methdos to iterated through
+  # the array of resources using {#first}, {#next}, {#last?} and {#first?}
+  #
+  # Paging information is provided by Ably in the LINK HTTP headers
+  class PagedResource
+    include Enumerable
+
+    # @param [Faraday::Response] http_response Initial HTTP response from an Ably request to a paged resource
+    # @param [String] base_url Base URL for request that generated the http_response so that subsequent paged requests can be made
+    # @param [Client] client {Ably::Client} used to make the request to Ably
+    # @param [Hash] options Options for this paged resource
+    # @option options [Symbol] :coerce_into symbol representing class that should be used to represent each item in the PagedResource
+    #
+    # @return [PagedResource]
+    def initialize(http_response, base_url, client, coerce_into: nil)
+      @http_response = http_response
+      @client        = client
+      @base_url      = "#{base_url.gsub(%r{/[^/]*$}, '')}/"
+      @coerce_into   = coerce_into
+
+      @body = if coerce_into
+        http_response.body.map do |item|
+          Kernel.const_get(coerce_into).new(item)
+        end
+      else
+        http_response.body
+      end
+    end
+
+    # Retrieve the first page of results
+    #
+    # @return [PagedResource]
+    def first
+      PagedResource.new(client.get(pagination_url('first')), base_url, client, coerce_into: coerce_into)
+    end
+
+    # Retrieve the next page of results
+    #
+    # @return [PagedResource]
+    def next
+      PagedResource.new(client.get(pagination_url('next')), base_url, client, coerce_into: coerce_into)
+    end
+
+    # True if this is the last page in the paged resource set
+    #
+    # @return [Boolean]
+    def last?
+      !supports_pagination? ||
+        pagination_header('next').nil?
+    end
+
+    # True if this is the first page in the paged resource set
+    #
+    # @return [Boolean]
+    def first?
+      !supports_pagination? ||
+        pagination_header('first') == pagination_header('current')
+    end
+
+    # True if the HTTP response supports paging with the expected LINK HTTP headers
+    #
+    # @return [Boolean]
+    def supports_pagination?
+      !pagination_headers.empty?
+    end
+
+    # Standard Array accessor method
+    def [](index)
+      body[index]
+    end
+
+    # Returns number of items within this page, not the total number of items in the entire paged resource set
+    def length
+      body.length
+    end
+    alias_method :count, :length
+    alias_method :size,  :length
+
+    # Method ensuring this {PagedResource} is {http://ruby-doc.org/core-2.1.3/Enumerable.html Enumerable}
+    def each(&block)
+      body.each do |item|
+        if block_given?
+          block.call item
+        else
+          yield item
+        end
+      end
+    end
+
+    private
+    attr_reader :body, :http_response, :base_url, :client, :coerce_into
+
+    def pagination_headers
+      link_regex = %r{<(?<url>[^>]+)>; rel="(?<rel>[^"]+)"}
+      @pagination_headers ||= http_response.headers['link'].scan(link_regex).inject({}) do |hash, val_array|
+        url, rel = val_array
+        hash[rel] = url
+        hash
+      end
+    end
+
+    def pagination_header(id)
+      pagination_headers[id]
+    end
+
+    def pagination_url(id)
+      raise Ably::Exceptions::InvalidPageError, "Paging heading link #{id} does not exist" unless pagination_header(id)
+
+      if pagination_header(id).match(%r{^\./})
+        "#{base_url}#{pagination_header(id)[2..-1]}"
+      else
+        pagination_header[id]
+      end
+    end
+  end
+end

data/lib/ably/rest/presence.rb

@@ -14,10 +14,10 @@ module Ably
 
       # Obtain the set of members currently present for a channel
       #
-      # @return [PagedResource] An Array of presence-message Hash objects that supports paging (next, first)
+      # @return [Models::PagedResource] An Array of presence-message Hash objects that supports paging (next, first)
       def get(options = {})
         response = client.get(base_path, options)
-        PagedResource.new(response, base_path, client)
+        Models::PagedResource.new(response, base_path, client)
       end
 
       # Return the presence messages history for the channel
@@ -28,11 +28,11 @@ module Ably
       #   - direction:  :forwards or :backwards (default is :backwards)
       #   - limit:      Maximum number of messages to retrieve up to 10,000
       #
-      # @return [PagedResource] An Array of presence-message Hash objects that supports paging (next, first)
+      # @return [Models::PagedResource] An Array of presence-message Hash objects that supports paging (next, first)
       def history(options = {})
         url = "#{base_path}/history"
         response = client.get(url, options)
-        PagedResource.new(response, url, client)
+        Models::PagedResource.new(response, url, client)
       end
 
       private

data/lib/ably/token.rb

@@ -40,7 +40,7 @@ module Ably
     end
 
     def ==(other)
-      other.class == self.class &&
+      other.kind_of?(Token) &&
         attributes == other.attributes
     end
 

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/spec/acceptance/realtime/channel_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe Ably::Realtime::Channel do
+  include RSpec::EventMachine
+
+  let(:client) do
+    Ably::Realtime::Client.new(api_key: api_key, environment: environment)
+  end
+  let(:channel_name) { SecureRandom.hex(2) }
+  let(:payload) { SecureRandom.hex(4) }
+
+  it 'attachs to a channel' do
+    attached = false
+
+    run_reactor do
+      channel = client.channel(channel_name)
+      channel.attach
+      channel.on(:attached) do
+        attached = true
+        stop_reactor
+      end
+    end
+
+    expect(attached).to eql(true)
+  end
+
+  it 'publishes 3 messages once attached' do
+    messages = []
+
+    run_reactor do
+      channel = client.channel(channel_name)
+      channel.attach
+      channel.on(:attached) do
+        3.times { channel.publish('event', payload) }
+      end
+      channel.subscribe do |message|
+        messages << message if message.data == payload
+        stop_reactor if messages.length == 3
+      end
+    end
+
+    expect(messages.count).to eql(3)
+  end
+
+  it 'publishes 3 messages from queue before attached' do
+    messages = []
+
+    run_reactor do
+      channel = client.channel(channel_name)
+      3.times { channel.publish('event', SecureRandom.hex) }
+      channel.subscribe do |message|
+        messages << message if message.name == 'event'
+        stop_reactor if messages.length == 3
+      end
+    end
+
+    expect(messages.count).to eql(3)
+  end
+
+  it 'publishes 3 messages from queue before attached in a single protocol message' do
+    messages = []
+
+    run_reactor do
+      channel = client.channel(channel_name)
+      3.times { channel.publish('event', SecureRandom.hex) }
+      channel.subscribe do |message|
+        messages << message if message.name == 'event'
+        stop_reactor if messages.length == 3
+      end
+    end
+
+    # All 3 messages should be batched into a single Protocol Message by the client library
+    # message_id = "{connection_id}:{message_serial}:{protocol_message_index}"
+
+    # Check that all messages share the same message_serial
+    message_serials = messages.map { |msg| msg.message_id.split(':')[1] }
+    expect(message_serials.uniq).to eql(["1"])
+
+    # Check that all messages use message index 0,1,2
+    message_indexes = messages.map { |msg| msg.message_id.split(':')[2] }
+    expect(message_indexes).to include("0", "1", "2")
+  end
+end
+
+

data/spec/acceptance/rest/auth_spec.rb

@@ -25,7 +25,7 @@ describe "REST" do
 
     %w(client_id ttl timestamp capability nonce).each do |option|
       context "option :#{option}", webmock: true do
-        let(:random)         { SecureRandom.hex }
+        let(:random)         { SecureRandom.random_number(1_000_000_000).to_s }
         let(:options)        { { option.to_sym => random } }
 
         let(:token_response) { { access_token: {} }.to_json }
@@ -47,7 +47,7 @@ describe "REST" do
       let(:key_id)        { SecureRandom.hex }
       let(:key_secret)    { SecureRandom.hex }
       let(:nonce)         { SecureRandom.hex }
-      let(:token_options) { { key_id: key_id, key_secret: key_secret, nonce: nonce, timestamp: Time.now.to_i } }
+      let(:token_options) { { key_id: key_id, key_secret: key_secret, nonce: nonce, timestamp: Time.now } }
       let(:token_request) { auth.create_token_request(token_options) }
       let(:mac) do
         hmac_for(token_request, key_secret)
@@ -271,7 +271,7 @@ describe "REST" do
 
     %w(ttl capability nonce timestamp client_id).each do |attribute|
       context "with option :#{attribute}" do
-        let(:option_value) { SecureRandom.hex }
+        let(:option_value) { SecureRandom.random_number(1_000_000_000) }
         before do
           options[attribute.to_sym] = option_value
         end
@@ -312,6 +312,15 @@ describe "REST" do
       end
     end
 
+    context "with :timestamp option" do
+      let(:token_request_time) { Time.now + 5 }
+      let(:options) { { timestamp: token_request_time } }
+
+      it 'uses the provided timestamp' do
+        expect(subject[:timestamp]).to eql(token_request_time.to_i)
+      end
+    end
+
     context "signing" do
       let(:options) do
         {
@@ -319,7 +328,7 @@ describe "REST" do
           ttl: SecureRandom.hex,
           capability: SecureRandom.hex,
           client_id: SecureRandom.hex,
-          timestamp: SecureRandom.hex,
+          timestamp: SecureRandom.random_number(1_000_000_000),
           nonce: SecureRandom.hex
         }
       end
@@ -360,7 +369,7 @@ describe "REST" do
       end
 
       it "fails if timestamp is invalid" do
-        expect { auth.request_token(timestamp: Time.now.to_i - 180) }.to raise_error do |error|
+        expect { auth.request_token(timestamp: Time.now - 180) }.to raise_error do |error|
           expect(error).to be_a(Ably::Exceptions::InvalidRequest)
           expect(error.status).to eql(401)
           expect(error.code).to eql(40101)

data/spec/acceptance/rest/channel_spec.rb

@@ -38,8 +38,8 @@ describe "REST" do
       expect(actual_history.size).to eql(3)
 
       expected_history.each do |message|
-        expect(actual_history).to include(Ably::Message.new(message))
-        expect(actual_history.map(&:raw_message)).to include(message)
+        expect(actual_history).to include(Ably::Rest::Models::Message.new(message))
+        expect(actual_history.map(&:json)).to include(message)
       end
     end
 

data/spec/spec_helper.rb

@@ -10,6 +10,7 @@ require 'webmock/rspec'
 require "ably"
 
 require "support/api_helper"
+require "support/event_machine_helper"
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true

data/spec/support/event_machine_helper.rb

@@ -0,0 +1,22 @@
+require 'timeout'
+
+module RSpec
+  module EventMachine
+    def run_reactor(timeout = 3)
+      Timeout::timeout(timeout + 0.5) do
+        EM.run do
+          yield
+
+          EM.add_timer(timeout) do
+            EM.stop
+            raise RuntimeError, "EventMachine test did not complete in #{timeout} seconds"
+          end
+        end
+      end
+    end
+
+    def stop_reactor
+      EM.stop
+    end
+  end
+end

data/spec/support/model_helper.rb

@@ -0,0 +1,67 @@
+require 'securerandom'
+
+shared_examples 'a realtime model' do |shared_options = {}|
+  let(:args) { ([model_options] + model_args) }
+  let(:model) { subject.new(*args) }
+
+  context 'attributes' do
+    let(:unique_value) { SecureRandom.hex }
+
+    Array(shared_options[:with_simple_attributes]).each do |attribute|
+      context "##{attribute}" do
+        let(:model_options) { { attribute.to_sym => unique_value } }
+
+        it "retrieves attribute :#{attribute}" do
+          expect(model.public_send(attribute)).to eql(unique_value)
+        end
+      end
+    end
+
+    context '#json' do
+      let(:model_options) { { action: 5 } }
+
+      it 'provides access to #json' do
+        expect(model.json).to eql(model_options)
+      end
+    end
+
+    context '#[]' do
+      let(:model_options) { { unusual: 'attribute' } }
+
+      it 'provides accessor method to #json' do
+        expect(model[:unusual]).to eql('attribute')
+      end
+    end
+  end
+
+  context '#==' do
+    let(:model_options) { { channel: 'unique' } }
+
+    it 'is true when attributes are the same' do
+      new_message = -> { subject.new(*args) }
+      expect(new_message[]).to eq(new_message[])
+    end
+
+    it 'is false when attributes are not the same' do
+      expect(subject.new(*[action: 1] + model_args)).to_not eq(subject.new(*[action: 2] + model_args))
+    end
+
+    it 'is false when class type differs' do
+      expect(subject.new(*[action: 1] + model_args)).to_not eq(nil)
+    end
+  end
+
+  context 'is immutable' do
+    let(:model_options) { { channel: 'name' } }
+
+    it 'prevents changes' do
+      expect { model.json[:channel] = 'new' }.to raise_error RuntimeError, /can't modify frozen Hash/
+    end
+
+    it 'dups options' do
+      expect(model.json[:channel]).to eql('name')
+      model_options[:channel] = 'new'
+      expect(model.json[:channel]).to eql('name')
+    end
+  end
+end