ably 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b4423dc2ad92073b07e69cb72a3acbbe2d0973a
-  data.tar.gz: 76c5bb17b624875ec6fea9300c3778b216635266
+  metadata.gz: d9ccb54c36b77720433fde71a6580424b91cbfc0
+  data.tar.gz: fb242c4a0ce0c6ddd96c217d9904ee5926fcf465
 SHA512:
-  metadata.gz: e107b6875dbfc0bd05ba14c48b37bb0d6fea3d514666353495ff12c822bcc62f09322a3442eed5239ccf1ac1df466e48cb59387970be373260bfb9c40f28dce2
-  data.tar.gz: aa9f928e0f48b74cb158d8f0b7b8d21dec755427b02bff93d8f73fd6233be0ec4f8a5926acfd7ee0de3d6e6c3aff364f005122b561d7db4ee18aa6c169934703
+  metadata.gz: 9b681c12026a2fd84f3e5b71dfd901513a90f4c9cdb04ed9bef887543ce8d29a9ce1ef5e18e281090e7eae3940732146743948a8d17efa0fd0d09da0b03a6bc9
+  data.tar.gz: 116e3a2d88b423cd4af365656af2269467cc21601567897c3dd26efc0425c5d73e578a5d924021aa957661da1c417af527cc49dc8ef83ed4eeb82990e5dd6e7a

data/README.md

@@ -1,9 +1,11 @@
-# Ably
+# [Ably](https://ably.io)
 
 A Ruby client library for [ably.io](https://ably.io), the real-time messaging service.
 
 ## Installation
 
+The client library is available as a [gem from RubyGems.org](https://rubygems.org/gems/ably).
+
 Add this line to your application's Gemfile:
 
     gem 'ably'
@@ -22,15 +24,14 @@ Or install it yourself as:
 
 Given:
 
-```
+```ruby
 client = Ably::Realtime.new(api_key: "xxxxx")
-
 channel = client.channel("test")
 ```
 
 Subscribe to all events:
 
-```
+```ruby
 channel.subscribe do |message|
   message[:name] #=> "greeting"
   message[:data] #=> "Hello World!"
@@ -39,7 +40,7 @@ end
 
 Only certain events:
 
-```
+```ruby
 channel.subscribe("myEvent") do |message|
   message[:name] #=> "myEvent"
   message[:data] #=> "myData"
@@ -48,11 +49,9 @@ end
 
 ### Publishing to a channel
 
-```
+```ruby
 client = Ably::Realtime.new(api_key: "xxxxx")
-
 channel = client.channel("test")
-
 channel.publish("greeting", "Hello World!")
 ```
 
@@ -60,37 +59,40 @@ channel.publish("greeting", "Hello World!")
 
 ### Publishing a message to a channel
 
-```
+```ruby
 client = Ably::Rest.new(api_key: "xxxxx")
-
 channel = client.channel("test")
-
 channel.publish("myEvent", "Hello!") #=> true
 ```
 
 ### Fetching a channel's history
 
-```
+```ruby
 client = Ably::Rest.new(api_key: "xxxxx")
-
 channel = client.channel("test")
-
 channel.history #=> [{:name=>"test", :data=>"payload"}]
 ```
 
-### Fetching your application's stats
+### Authentication with a token
 
-```
+```ruby
 client = Ably::Rest.new(api_key: "xxxxx")
+client.auth.authorise # creates a token and will use token authentication moving forwards
+client.auth.current_token #=> #<Ably::Token>
+channel.publish("myEvent", "Hello!") #=> true, sent using token authentication
+```
 
+### Fetching your application's stats
+
+```ruby
+client = Ably::Rest.new(api_key: "xxxxx")
 client.stats #=> [{:channels=>..., :apiRequests=>..., ...}]
 ```
 
 ### Fetching the Ably service time
 
-```
+```ruby
 client = Ably::Rest.new(api_key: "xxxxx")
-
 client.time #=> 2013-12-12 14:23:34 +0000
 ```
 

data/lib/ably.rb

@@ -2,6 +2,7 @@ require "ably/support"
 
 require "ably/auth"
 require "ably/exceptions"
+require "ably/message"
 require "ably/rest"
 require "ably/realtime"
 require "ably/token"

data/lib/ably/auth.rb

@@ -37,6 +37,8 @@ module Ably
     # @param [Hash] auth_options          see {Ably::Rest::Client#initialize}
     # @yield [auth_options]               see {Ably::Rest::Client#initialize}
     def initialize(client, auth_options, &auth_block)
+      auth_options = auth_options.dup
+
       @client        = client
       @options       = auth_options
       @auth_callback = auth_block if block_given?
@@ -160,7 +162,7 @@ module Ably
 
       response = client.post("/keys/#{token_request.fetch(:id)}/requestToken", token_request, send_auth_header: false)
 
-      Ably::Token.new(response.body[:access_token])
+      Ably::Token.new(response.body.fetch(:access_token))
     end
 
     # Creates and signs a token request that can then subsequently be used by any client to request a token
@@ -194,7 +196,7 @@ module Ably
       request_key_id     = token_options.delete(:key_id) || key_id
       request_key_secret = token_options.delete(:key_secret) || key_secret
 
-      raise TokenRequestError, "Key ID and Key Secret are required to generate a new token request" unless request_key_id && request_key_secret
+      raise Ably::Exceptions::TokenRequestError, "Key ID and Key Secret are required to generate a new token request" unless request_key_id && request_key_secret
 
       timestamp = if token_options[:query_time]
         client.time
@@ -261,11 +263,23 @@ module Ably
       end
     end
 
+    # True if prerequisites for creating a new token request are present
+    #
+    # One of the following criterion must be met:
+    # * Valid key id and secret
+    # * Authentication callback for new token requests
+    # * Authentication URL for new token requests
+    #
+    # @return [Boolean]
+    def token_renewable?
+      token_creatable_externally? || api_key_present?
+    end
+
     private
     attr_reader :auth_callback
 
     def basic_auth_header
-      raise InsecureRequestError, "Cannot use Basic Auth over non-TLS connections" unless client.use_tls?
+      raise Ably::Exceptions::InsecureRequestError, "Cannot use Basic Auth over non-TLS connections" unless client.use_tls?
       "Basic #{encode64("#{api_key}")}"
     end
 
@@ -363,10 +377,6 @@ module Ably
       token_callback_present? || token_url_present?
     end
 
-    def token_renewable?
-      use_basic_auth? || token_creatable_externally?
-    end
-
     def has_client_id?
       !!client_id
     end

data/lib/ably/exceptions.rb

@@ -1,16 +1,38 @@
 module Ably
-  class InvalidRequest < StandardError
-    attr_reader :status, :code
-    def initialize(message, status: nil, code: nil)
-      super message
-      @status = status
-      @code = code
+  module Exceptions
+    # An invalid request was received by Ably
+    #
+    # @!attribute [r] message
+    #   @return [String] Error message from Ably
+    # @!attribute [r] status
+    #   @return [String] HTTP status code of error
+    # @!attribute [r] code
+    #   @return [String] Ably specific error code
+    class InvalidRequest < StandardError
+      attr_reader :status, :code
+      def initialize(message, status: nil, code: nil)
+        super message
+        @status = status
+        @code = code
+      end
     end
-  end
 
-  class ServerError < StandardError; end
-  class InvalidPageError < StandardError; end
-  class InvalidResponseBody < StandardError; end
-  class InsecureRequestError < StandardError; end
-  class TokenRequestError < StandardError; end
+    # The HTTP request has returned a 500 error
+    class ServerError < StandardError; end
+
+    # PagedResource cannot retrieve the page
+    class InvalidPageError < StandardError; end
+
+    # The expected response from the server was invalid
+    class InvalidResponseBody < StandardError; end
+
+    # The request cannot be performed because it is insecure
+    class InsecureRequestError < StandardError; end
+
+    # The token request could not be created
+    class TokenRequestError < StandardError; end
+
+    # The token is invalid
+    class InvalidToken < InvalidRequest; end
+  end
 end

data/lib/ably/message.rb

@@ -0,0 +1,70 @@
+module Ably
+  # A Message encapsulates an individual message sent or received in Ably
+  class Message
+    def initialize(message)
+      @message = message.dup.freeze
+    end
+
+    # Event name
+    #
+    # @return [String]
+    def name
+      @message[:name]
+    end
+
+    # Payload
+    #
+    # @return [Object]
+    def data
+      @message[:data]
+    end
+
+    # Client ID of the publisher of the message
+    #
+    # @return [String]
+    def client_id
+      @message[:client_id]
+    end
+
+    # Timestamp in milliseconds since epoch.  This property is populated by the Ably system.
+    #
+    # @return [Integer]
+    def timestamp
+      @message[:timestamp]
+    end
+
+    # Timestamp as {Time}.  This property is populated by the Ably system.
+    #
+    # @return [Time]
+    def timestamp_at
+      raise RuntimeError, "Timestamp is missing" unless timestamp
+      Time.at(timestamp / 1000.0)
+    end
+
+    # Unique serial number of this message within the channel
+    #
+    # @return [Integer]
+    def channel_serial
+      @message[:channel_serial]
+    end
+
+    # Provide a normal Hash accessor to the underlying raw message object
+    #
+    # @return [Object]
+    def [](key)
+      @message[key]
+    end
+
+    # Raw message object
+    #
+    # @return [Hash]
+    def raw_message
+      @message
+    end
+
+    def ==(other)
+      self.kind_of?(other.class) &&
+        raw_message == other.raw_message
+    end
+  end
+end

data/lib/ably/rest.rb

@@ -1,4 +1,5 @@
 require "ably/rest/channel"
+require "ably/rest/channels"
 require "ably/rest/client"
 require "ably/rest/paged_resource"
 require "ably/rest/presence"

data/lib/ably/rest/channel.rb

@@ -1,25 +1,30 @@
 module Ably
   module Rest
+    # The Ably Realtime service organises the traffic within any application into named channels.
+    # Channels are the "unit" of message distribution; clients attach to channels to subscribe to messages, and every message broadcast by the service is associated with a unique channel.
     class Channel
-      attr_reader :client, :name
+      attr_reader :client, :name, :options
 
       # Initialize a new Channel object
       #
       # @param client [Ably::Rest::Client]
       # @param name [String] The name of the channel
-      def initialize(client, name)
-        @client = client
-        @name   = name
+      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      def initialize(client, name, channel_options = {})
+        @client  = client
+        @name    = name
+        @options = channel_options.dup.freeze
       end
 
       # Publish a message to the channel
       #
-      # @param message [Hash] The message to publish (must contain :name and :data keys)
+      # @param name [String] The event name of the message to publish
+      # @param data [String] The message payload
       # @return [Boolean] true if the message was published, otherwise false
-      def publish(event, message)
+      def publish(name, data)
         payload = {
-          name: event,
-          data: message
+          name: name,
+          data: data
         }
 
         response = client.post("#{base_path}/publish", payload)
@@ -29,12 +34,12 @@ module Ably
 
       # Return the message history of the channel
       #
-      # Options:
-      #   - start:      Time or millisecond since epoch
-      #   - end:        Time or millisecond since epoch
-      #   - direction:  :forwards or :backwards
-      #   - limit:      Maximum number of messages to retrieve up to 10,000
-      #   - by:         :message, :bundle or :hour. Defaults to :message
+      # @param [Hash] options the options for the message history request
+      # @option options [Integer]   :start      Time or millisecond since epoch
+      # @option options [Integer]   :end        Time or millisecond since epoch
+      # @option options [Symbol]    :direction  `:forwards` or `:backwards`
+      # @option options [Integer]   :limit      Maximum number of messages to retrieve up to 10,000
+      # @option options [Symbol]    :by         `:message`, `:bundle` or `:hour`. Defaults to `:message`
       #
       # @return [PagedResource] An Array of hashes representing the message history that supports paging (next, first)
       def history(options = {})
@@ -42,7 +47,7 @@ module Ably
         # TODO: Remove live param as all history should be live
         response = client.get(url, options.merge(live: true))
 
-        PagedResource.new(response, url, client)
+        PagedResource.new(response, url, client, coerce_into: 'Ably::Message')
       end
 
       def presence

data/lib/ably/rest/channels.rb

@@ -0,0 +1,30 @@
+module Ably
+  module Rest
+    class Channels
+      attr_reader :client
+
+      # Initialize a new Channels object
+      #
+      # {Ably::Rest::Channels} provides simple accessor methods to access a {Ably::Rest::Channel} object
+      def initialize(client)
+        @client   = client
+        @channels = {}
+      end
+
+      # Return a REST {Ably::Rest::Channel} for the given name
+      #
+      # @param name [String] The name of the channel
+      # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+      #
+      # @return [Ably::Rest::Channel]
+      def get(name, channel_options = {})
+        @channels[name] ||= Ably::Rest::Channel.new(client, name, channel_options)
+      end
+      alias_method :[], :get
+
+      def close(channel)
+        @channels.delete(channel)
+      end
+    end
+  end
+end

data/lib/ably/rest/client.rb

@@ -24,7 +24,7 @@ module Ably
 
       DOMAIN = "rest.ably.io"
 
-      attr_reader :tls, :environment, :auth
+      attr_reader :tls, :environment, :auth, :channels
       def_delegator :auth, :client_id, :auth_options
 
       # Creates a {Ably::Rest::Client Rest Client} and configures the {Ably::Auth} object for the connection.
@@ -61,6 +61,8 @@ module Ably
       #    client = Ably::Rest::Client.new(api_key: 'key.id:secret', client_id: 'john')
       #
       def initialize(options, &auth_block)
+        options = options.dup
+
         if options.kind_of?(String)
           options = { api_key: options }
         end
@@ -69,16 +71,16 @@ module Ably
         @environment         = options.delete(:environment) # nil is production
         @debug_http          = options.delete(:debug_http)
 
-        @auth = Auth.new(self, options, &auth_block)
+        @auth     = Auth.new(self, options, &auth_block)
+        @channels = Ably::Rest::Channels.new(self)
       end
 
       # Return a REST {Ably::Rest::Channel} for the given name
       #
-      # @param name [String] The name of the channel
-      # @return [Ably::Rest::Channel]
-      def channel(name)
-        @channels ||= {}
-        @channels[name] ||= Ably::Rest::Channel.new(self, name)
+      # @param [String] name see {Ably::Rest::Channels#get}
+      # @param [Hash] channel_options see {Ably::Rest::Channels#get}
+      def channel(name, channel_options = {})
+        channels.get(name, channel_options)
       end
 
       # Return the stats for the application
@@ -137,9 +139,26 @@ module Ably
 
       private
       def request(method, path, params = {}, options = {})
-        connection.send(method, path, params) do |request|
-          unless options[:send_auth_header] == false
-            request.headers[:authorization] = auth.auth_header
+        reauthorise_on_authorisation_failure do
+          connection.send(method, path, params) do |request|
+            unless options[:send_auth_header] == false
+              request.headers[:authorization] = auth.auth_header
+            end
+          end
+        end
+      end
+
+      def reauthorise_on_authorisation_failure
+        attempts = 0
+        begin
+          yield
+        rescue Ably::Exceptions::InvalidRequest => e
+          attempts += 1
+          if attempts == 1 && e.code == 40140 && auth.token_renewable?
+            auth.authorise force: true
+            retry
+          else
+            raise Ably::Exceptions::InvalidToken.new(e.message, status: e.status, code: e.code)
           end
         end
       end

data/lib/ably/rest/middleware/exceptions.rb

@@ -29,9 +29,9 @@ module Ably
               message = "Unknown server error" if message.to_s.strip == ''
 
               if env[:status] >= 500
-                raise Ably::ServerError, message
+                raise Ably::Exceptions::ServerError, message
               else
-                raise Ably::InvalidRequest.new(message, status: error_status_code, code: error_code)
+                raise Ably::Exceptions::InvalidRequest.new(message, status: error_status_code, code: error_code)
               end
             end
           end

data/lib/ably/rest/middleware/external_exceptions.rb

@@ -13,9 +13,9 @@ module Ably
               message = "Error #{error_status_code}: #{(env[:body] || '')[0...200]}"
 
               if error_status_code >= 500
-                raise Ably::ServerError, message
+                raise Ably::Exceptions::ServerError, message
               else
-                raise Ably::InvalidRequest, message
+                raise Ably::Exceptions::InvalidRequest, message
               end
             end
           end

data/lib/ably/rest/middleware/parse_json.rb

@@ -7,7 +7,7 @@ module Ably
         def parse(body)
           JSON.parse(body, symbolize_names: true)
         rescue JSON::ParserError => e
-          raise InvalidResponseBody, "Expected JSON response. #{e.message}"
+          raise Ably::Exceptions::InvalidResponseBody, "Expected JSON response. #{e.message}"
         end
       end
     end

data/lib/ably/rest/paged_resource.rb

@@ -10,27 +10,37 @@ module Ably
       # @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 [Ably::Rest::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 [Ably::Rest::PagedResource]
-      def initialize(http_response, base_url, client)
+      def initialize(http_response, base_url, client, coerce_into: nil)
         @http_response = http_response
-        @body          = http_response.body
         @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 [Ably::Rest::PagedResource]
       def first
-        PagedResource.new(@client.get(pagination_url('first')), @base_url, @client)
+        PagedResource.new(@client.get(pagination_url('first')), @base_url, @client, coerce_into: @coerce_into)
       end
 
       # Retrieve the next page of results
       #
       # @return [Ably::Rest::PagedResource]
       def next
-        PagedResource.new(@client.get(pagination_url('next')), @base_url, @client)
+        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
@@ -94,7 +104,7 @@ module Ably
       end
 
       def pagination_url(id)
-        raise InvalidPageError, "Paging heading link #{id} does not exist" unless pagination_header(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]}"

data/lib/ably/token.rb

@@ -8,7 +8,7 @@ module Ably
     TOKEN_EXPIRY_BUFFER = 5
 
     def initialize(attributes)
-      @attributes = attributes.freeze
+      @attributes = attributes.dup.freeze
     end
 
     def id

data/lib/ably/version.rb

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

data/spec/acceptance/rest/auth_spec.rb

@@ -156,7 +156,7 @@ describe "REST" do
           end
 
           it 'raises ServerError' do
-            expect { auth.request_token options }.to raise_error(Ably::ServerError)
+            expect { auth.request_token options }.to raise_error(Ably::Exceptions::ServerError)
           end
         end
 
@@ -167,7 +167,7 @@ describe "REST" do
           end
 
           it 'raises InvalidResponseBody' do
-            expect { auth.request_token options }.to raise_error(Ably::InvalidResponseBody)
+            expect { auth.request_token options }.to raise_error(Ably::Exceptions::InvalidResponseBody)
           end
         end
       end
@@ -294,11 +294,11 @@ describe "REST" do
       let(:client) { Ably::Rest::Client.new(auth_url: 'http://example.com') }
 
       it "should raise an exception if key secret is missing" do
-        expect { auth.create_token_request(key_id: 'id') }.to raise_error Ably::TokenRequestError
+        expect { auth.create_token_request(key_id: 'id') }.to raise_error Ably::Exceptions::TokenRequestError
       end
 
       it "should raise an exception if key id is missing" do
-        expect { auth.create_token_request(key_secret: 'secret') }.to raise_error Ably::TokenRequestError
+        expect { auth.create_token_request(key_secret: 'secret') }.to raise_error Ably::Exceptions::TokenRequestError
       end
     end
 
@@ -353,7 +353,7 @@ describe "REST" do
 
       it "disallows publishing on unspecified capability channels" do
         expect { token_auth_client.channel("bar").publish("event", "data") }.to raise_error do |error|
-          expect(error).to be_a(Ably::InvalidRequest)
+          expect(error).to be_a(Ably::Exceptions::InvalidRequest)
           expect(error.status).to eql(401)
           expect(error.code).to eql(40160)
         end
@@ -361,7 +361,7 @@ describe "REST" do
 
       it "fails if timestamp is invalid" do
         expect { auth.request_token(timestamp: Time.now.to_i - 180) }.to raise_error do |error|
-          expect(error).to be_a(Ably::InvalidRequest)
+          expect(error).to be_a(Ably::Exceptions::InvalidRequest)
           expect(error.status).to eql(401)
           expect(error.code).to eql(40101)
         end
@@ -417,7 +417,7 @@ describe "REST" do
           capability_with_str_key = Ably::Token::DEFAULTS[:capability]
           capability = Hash[capability_with_str_key.keys.map(&:to_sym).zip(capability_with_str_key.values)]
           expect(token.capability).to eql(capability)
-          expect(token.expires_at).to be_within(2).of(Time.now + Ably::Token::DEFAULTS[:ttl])
+          expect(token.expires_at.to_i).to be_within(2).of(Time.now.to_i + Ably::Token::DEFAULTS[:ttl])
           expect(token.client_id).to eql(client_id)
         end
       end

data/spec/acceptance/rest/base_spec.rb

@@ -7,10 +7,10 @@ describe "REST" do
   end
 
   describe "invalid requests in middleware" do
-    it "should raise a InvalidRequest exception with a valid message" do
+    it "should raise an InvalidRequest exception with a valid message" do
       invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret')
       expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
-        expect(error).to be_a(Ably::InvalidRequest)
+        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)
@@ -25,7 +25,7 @@ describe "REST" do
       end
 
       it "should raise a ServerError exception" do
-        expect { client.time }.to raise_error(Ably::ServerError, /Internal error/)
+        expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Internal error/)
       end
     end
 
@@ -35,7 +35,60 @@ describe "REST" do
       end
 
       it "should raise a ServerError exception" do
-        expect { client.time }.to raise_error(Ably::ServerError, /Unknown/)
+        expect { client.time }.to raise_error(Ably::Exceptions::ServerError, /Unknown/)
+      end
+    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 => '[]' }
+        else
+          raise Ably::Exceptions::InvalidRequest.new('Authentication failure', status: 401, code: 40140)
+        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

data/spec/acceptance/rest/channel_spec.rb

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

data/spec/acceptance/rest/channels_spec.rb

@@ -0,0 +1,39 @@
+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' } }
+
+  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
+
+  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 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

data/spec/unit/auth.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ably::Auth do
   let(:client) { Ably::Rest::Client.new(key_id: 'id', key_secret: 'secret') }
 
-  it "should not allow changes to the options" do
+  it "has immutable options" do
     expect { client.auth.options['key_id'] = 'new_id' }.to raise_error RuntimeError, /can't modify frozen Hash/
   end
 end

data/spec/unit/message_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Ably::Message do
+  context 'attributes' do
+    let(:unique_value) { 'unique_value' }
+
+    %w(name data client_id timestamp channel_serial).each do |attribute|
+      context "##{attribute}" do
+        subject { Ably::Message.new({ attribute.to_sym => unique_value }) }
+
+        it "retrieves attribute :#{attribute}" do
+          expect(subject.public_send(attribute)).to eql(unique_value)
+        end
+      end
+    end
+
+    context '#timestamp_at' do
+      subject { Ably::Message.new(timestamp: Time.now.to_i * 1000) }
+      it 'retrieves attribute :key' do
+        expect(subject.timestamp_at.to_i).to be_within(1).of(Time.now.to_i)
+      end
+    end
+
+    context '#raw_message' do
+      let(:attributes) { { timestamp: Time.now.to_i * 1000 } }
+      subject { Ably::Message.new(attributes) }
+
+      it 'provides access to #raw_message' do
+        expect(subject.raw_message).to eql(attributes)
+      end
+    end
+
+    context '#[]' do
+      subject { Ably::Message.new(unusual: 'attribute') }
+
+      it 'provides accessor method to #raw_message' do
+        expect(subject[:unusual]).to eql('attribute')
+      end
+    end
+  end
+
+  context '==' do
+    let(:attributes) { { client_id: 'unique' } }
+
+    it 'is true when attributes are the same' do
+      new_message = -> { Ably::Message.new(attributes) }
+      expect(new_message[]).to eq(new_message[])
+    end
+
+    it 'is false when attributes are not the same' do
+      expect(Ably::Message.new(client_id: 1)).to_not eq(Ably::Message.new(client_id: 2))
+    end
+
+    it 'is false when class type differs' do
+      expect(Ably::Message.new(client_id: 1)).to_not eq(nil)
+    end
+  end
+
+  context 'is immutable' do
+    let(:options) { { client_id: 'John' } }
+    subject { Ably::Message.new(options) }
+
+    it 'prevents changes' do
+      expect { subject.raw_message[:client_id] = 'Joe' }.to raise_error RuntimeError, /can't modify frozen Hash/
+    end
+
+    it 'dups options' do
+      expect(subject.raw_message[:client_id]).to eql('John')
+      options[:client_id] = 'Joe'
+      expect(subject.raw_message[:client_id]).to eql('John')
+    end
+  end
+end

data/spec/unit/rest_spec.rb

@@ -75,7 +75,7 @@ describe Ably::Rest do
         end
 
         it 'fails when authenticating with basic auth' do
-          expect { client.channel('a').publish('event', 'message') }.to raise_error(Ably::InsecureRequestError)
+          expect { client.channel('a').publish('event', 'message') }.to raise_error(Ably::Exceptions::InsecureRequestError)
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ably
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Lewis Marshall
@@ -168,6 +168,7 @@ files:
 - lib/ably.rb
 - lib/ably/auth.rb
 - lib/ably/exceptions.rb
+- lib/ably/message.rb
 - lib/ably/realtime.rb
 - lib/ably/realtime/callbacks.rb
 - lib/ably/realtime/channel.rb
@@ -175,6 +176,7 @@ files:
 - lib/ably/realtime/connection.rb
 - lib/ably/rest.rb
 - lib/ably/rest/channel.rb
+- lib/ably/rest/channels.rb
 - lib/ably/rest/client.rb
 - lib/ably/rest/middleware/exceptions.rb
 - lib/ably/rest/middleware/external_exceptions.rb
@@ -188,6 +190,7 @@ files:
 - spec/acceptance/rest/auth_spec.rb
 - spec/acceptance/rest/base_spec.rb
 - spec/acceptance/rest/channel_spec.rb
+- spec/acceptance/rest/channels_spec.rb
 - spec/acceptance/rest/presence_spec.rb
 - spec/acceptance/rest/stats_spec.rb
 - spec/acceptance/rest/time_spec.rb
@@ -195,6 +198,7 @@ files:
 - spec/support/api_helper.rb
 - spec/support/test_app.rb
 - spec/unit/auth.rb
+- spec/unit/message_spec.rb
 - spec/unit/realtime_spec.rb
 - spec/unit/rest_spec.rb
 - spec/unit/token_spec.rb
@@ -227,6 +231,7 @@ test_files:
 - spec/acceptance/rest/auth_spec.rb
 - spec/acceptance/rest/base_spec.rb
 - spec/acceptance/rest/channel_spec.rb
+- spec/acceptance/rest/channels_spec.rb
 - spec/acceptance/rest/presence_spec.rb
 - spec/acceptance/rest/stats_spec.rb
 - spec/acceptance/rest/time_spec.rb
@@ -234,6 +239,7 @@ test_files:
 - spec/support/api_helper.rb
 - spec/support/test_app.rb
 - spec/unit/auth.rb
+- spec/unit/message_spec.rb
 - spec/unit/realtime_spec.rb
 - spec/unit/rest_spec.rb
 - spec/unit/token_spec.rb