ably-rest 0.8.2 → 0.8.3

data/lib/submodules/ably-ruby/lib/ably/rest/channel.rb

@@ -25,30 +25,51 @@ module Ably
       def initialize(client, name, channel_options = {})
         ensure_utf_8 :name, name
 
+        update_options channel_options
         @client  = client
         @name    = name
-        @options = channel_options.clone.freeze
       end
 
-      # Publish a message to the channel
+      # Publish one or more messages to the channel.
       #
-      # @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(name, data)
-        ensure_utf_8 :name, name
-        ensure_supported_payload data
-
-        payload = {
-          name: name,
-          data: data
-        }
+      # @param name [String, Array<Ably::Models::Message|Hash>, nil]   The event name of the message to publish, or an Array of [Ably::Model::Message] objects or [Hash] objects with +:name+ and +:data+ pairs
+      # @param data [String, ByteArray, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument
+      # @return [Boolean]  true if the message was published, otherwise false
+      #
+      # @example
+      #   # Publish a single message
+      #   channel.publish 'click', { x: 1, y: 2 }
+      #
+      #   # Publish an array of message Hashes
+      #   messages = [
+      #     { name: 'click', { x: 1, y: 2 } },
+      #     { name: 'click', { x: 2, y: 3 } }
+      #   ]
+      #   channel.publish messages
+      #
+      #   # Publish an array of Ably::Models::Message objects
+      #   messages = [
+      #     Ably::Models::Message(name: 'click', { x: 1, y: 2 })
+      #     Ably::Models::Message(name: 'click', { x: 2, y: 3 })
+      #   ]
+      #   channel.publish messages
+      #
+      def publish(name, data = nil)
+        messages = if name.kind_of?(Enumerable)
+          name
+        else
+          ensure_utf_8 :name, name, allow_nil: true
+          ensure_supported_payload data
+          [{ name: name, data: data }]
+        end
 
-        message = Ably::Models::Message.new(payload).tap do |message|
-          message.encode self
+        payload = messages.map do |message|
+          Ably::Models::Message(message.dup).tap do |message|
+            message.encode self
+          end.as_json
         end
 
-        response = client.post("#{base_path}/publish", message)
+        response = client.post("#{base_path}/publish", payload.length == 1 ? payload.first : payload)
 
         [201, 204].include?(response.status)
       end
@@ -71,6 +92,7 @@ module Ably
         }.merge(options)
 
         [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+        raise ArgumentError, ":end must be equal to or after :start" if options[:start] && options[:end] && (options[:start] > options[:end])
 
         paginated_options = {
           coerce_into: 'Ably::Models::Message',
@@ -93,6 +115,11 @@ module Ably
         @presence ||= Presence.new(client, self)
       end
 
+      # @api private
+      def update_options(channel_options)
+        @options = channel_options.clone.freeze
+      end
+
       private
       def base_path
         "/channels/#{CGI.escape(name)}"

data/lib/submodules/ably-ruby/lib/ably/rest/client.rb

@@ -55,6 +55,14 @@ module Ably
       # @return [String,Nil]
       attr_reader :custom_host
 
+      # The custom port for non-TLS requests if it was provided with the option `:port` when the {Client} was created
+      # @return [Integer,Nil]
+      attr_reader :custom_port
+
+      # The custom TLS port for TLS requests if it was provided with the option `:tls_port` when the {Client} was created
+      # @return [Integer,Nil]
+      attr_reader :custom_tls_port
+
       # The registered encoders that are used to encode and decode message payloads
       # @return [Array<Ably::Models::MessageEncoder::Base>]
       # @api private
@@ -68,17 +76,25 @@ module Ably
       # Creates a {Ably::Rest::Client Rest Client} and configures the {Ably::Auth} object for the connection.
       #
       # @param [Hash,String] options an options Hash used to configure the client and the authentication, or String with an API key or Token ID
-      # @option options (see Ably::Auth#authorise)
-      # @option options [Boolean]                 :tls                 TLS is used by default, providing a value of false disables TLS.  Please note Basic Auth is disallowed without TLS as secrets cannot be transmitted over unsecured connections.
+      # @option options [Boolean]                 :tls                (true) When fales, TLS is disabled. Please note Basic Auth is disallowed without TLS as secrets cannot be transmitted over unsecured connections.
       # @option options [String]                  :key                 API key comprising the key name and key secret in a single string
       # @option options [String]                  :token               Token string or {Models::TokenDetails} used to authenticate requests
       # @option options [String]                  :token_details       {Models::TokenDetails} used to authenticate requests
       # @option options [Boolean]                 :use_token_auth      Will force Basic Auth if set to false, and Token auth if set to true
       # @option options [String]                  :environment         Specify 'sandbox' when testing the client library against an alternate Ably environment
-      # @option options [Symbol]                  :protocol            Protocol used to communicate with Ably, :json and :msgpack currently supported. Defaults to :msgpack
-      # @option options [Boolean]                 :use_binary_protocol Protocol used to communicate with Ably, defaults to true and uses MessagePack protocol.  This option will overide :protocol option
-      # @option options [Logger::Severity,Symbol] :log_level           Log level for the standard Logger that outputs to STDOUT.  Defaults to Logger::ERROR, can be set to :fatal (Logger::FATAL), :error (Logger::ERROR), :warn (Logger::WARN), :info (Logger::INFO), :debug (Logger::DEBUG) or :none
+      # @option options [Symbol]                  :protocol            (:msgpack) Protocol used to communicate with Ably, :json and :msgpack currently supported
+      # @option options [Boolean]                 :use_binary_protocol (true) When true will use the MessagePack binary protocol, when false it will use JSON encoding. This option will overide :protocol option
+      # @option options [Logger::Severity,Symbol] :log_level           (Logger::WARN) Log level for the standard Logger that outputs to STDOUT. Can be set to :fatal (Logger::FATAL), :error (Logger::ERROR), :warn (Logger::WARN), :info (Logger::INFO), :debug (Logger::DEBUG) or :none
       # @option options [Logger]                  :logger              A custom logger can be used however it must adhere to the Ruby Logger interface, see http://www.ruby-doc.org/stdlib-1.9.3/libdoc/logger/rdoc/Logger.html
+      # @option options [String]                  :client_id           client ID identifying this connection to other clients
+      # @option options [String]                  :auth_url            a URL to be used to GET or POST a set of token request params, to obtain a signed token request
+      # @option options [Hash]                    :auth_headers        a set of application-specific headers to be added to any request made to the +auth_url+
+      # @option options [Hash]                    :auth_params         a set of application-specific query params to be added to any request made to the +auth_url+
+      # @option options [Symbol]                  :auth_method         (:get) HTTP method to use with +auth_url+, must be either +:get+ or +:post+
+      # @option options [Proc]                    :auth_callback       when provided, the Proc will be called with the token params hash as the first argument, whenever a new token is required.
+      #                                                                The Proc should return a token string, {Ably::Models::TokenDetails} or JSON equivalent, {Ably::Models::TokenRequest} or JSON equivalent
+      # @option options [Boolean]                 :query_time          when true will query the {https://www.ably.io Ably} system for the current time instead of using the local time
+      # @option options [Hash]                    :token_params        convenience to pass in +token_params+ that will be used as a default for all token requests. See {Auth#create_token_request}
       #
       # @return [Ably::Rest::Client]
       #
@@ -101,13 +117,15 @@ module Ably
           end
         end
 
-        @tls           = options.delete(:tls) == false ? false : true
-        @environment   = options.delete(:environment) # nil is production
-        @protocol      = options.delete(:protocol) || :msgpack
-        @debug_http    = options.delete(:debug_http)
-        @log_level     = options.delete(:log_level) || ::Logger::ERROR
-        @custom_logger = options.delete(:logger)
-        @custom_host   = options.delete(:rest_host)
+        @tls              = options.delete(:tls) == false ? false : true
+        @environment      = options.delete(:environment) # nil is production
+        @protocol         = options.delete(:protocol) || :msgpack
+        @debug_http       = options.delete(:debug_http)
+        @log_level        = options.delete(:log_level) || ::Logger::WARN
+        @custom_logger    = options.delete(:logger)
+        @custom_host      = options.delete(:rest_host)
+        @custom_port      = options.delete(:port)
+        @custom_tls_port  = options.delete(:tls_port)
 
         if @log_level == :none
           @custom_logger = Ably::Models::NilLogger.new
@@ -124,11 +142,14 @@ module Ably
         end
         raise ArgumentError, 'Protocol is invalid.  Must be either :msgpack or :json' unless [:msgpack, :json].include?(@protocol)
 
-        @options  = options.freeze
-        @auth     = Auth.new(self, options)
+        token_params = options.delete(:token_params) || {}
+        @options  = options
+        @auth     = Auth.new(self, options, token_params)
         @channels = Ably::Rest::Channels.new(self)
         @encoders = []
 
+        options.freeze
+
         initialize_default_encoders
       end
 
@@ -160,6 +181,7 @@ module Ably
         }.merge(options)
 
         [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+        raise ArgumentError, ":end must be equal to or after :start" if options[:start] && options[:end] && (options[:start] > options[:end])
 
         paginated_options = {
           coerce_into: 'Ably::Models::Stats'
@@ -314,7 +336,7 @@ module Ably
             end
           end
 
-        rescue Faraday::TimeoutError, Faraday::ClientError => error
+        rescue Faraday::TimeoutError, Faraday::ClientError, Ably::Exceptions::ServerError => error
           time_passed = Time.now - requested_at
           if can_fallback_to_alternate_ably_host? && retry_count < max_retry_attempts && time_passed <= cumulative_timeout
             retry_count += 1
@@ -323,33 +345,42 @@ module Ably
 
           case error
             when Faraday::TimeoutError
-              raise Ably::Exceptions::ConnectionTimeoutError.new(error.message, nil, 80014, error)
+              raise Ably::Exceptions::ConnectionTimeout.new(error.message, nil, 80014, error)
             when Faraday::ClientError
               raise Ably::Exceptions::ConnectionError.new(error.message, nil, 80000, error)
+            else
+              raise error
           end
         end
       end
 
       def reauthorise_on_authorisation_failure
         yield
-      rescue Ably::Exceptions::InvalidRequest => e
-        if e.code == 40140
-          if auth.token_renewable?
-            auth.authorise force: true
-            yield
-          else
-            raise Ably::Exceptions::InvalidToken.new(e.message, e.status, e.code)
-          end
+      rescue Ably::Exceptions::TokenExpired => e
+        if auth.token_renewable?
+          auth.authorise force: true
+          yield
         else
           raise e
         end
       end
 
       def endpoint_for_host(host)
-        URI::Generic.build(
+        port = if use_tls?
+          custom_tls_port
+        else
+          custom_port
+        end
+
+        raise ArgumentError, "Custom port must be an Integer or nil" if port && !port.kind_of?(Integer)
+
+        options = {
           scheme: use_tls? ? 'https' : 'http',
           host:   host
-        )
+        }
+        options.merge!(port: port) if port
+
+        URI::Generic.build(options)
       end
 
       # Return a Hash of connection options to initiate the Faraday::Connection with

data/lib/submodules/ably-ruby/lib/ably/rest/middleware/exceptions.rb

@@ -29,7 +29,9 @@ module Ably
             message = 'Unknown server error' if message.to_s.strip == ''
 
             if env.status >= 500
-              raise Ably::Exceptions::ServerError, message
+              raise Ably::Exceptions::ServerError.new(message, error_status_code, error_code)
+            elsif env.status == 401 && error_code == 40140
+              raise Ably::Exceptions::TokenExpired.new(message, error_status_code, error_code)
             else
               raise Ably::Exceptions::InvalidRequest.new(message, error_status_code, error_code)
             end

data/lib/submodules/ably-ruby/lib/ably/rest/middleware/fail_if_unsupported_mime_type.rb

@@ -7,8 +7,10 @@ module Ably
       class FailIfUnsupportedMimeType < Faraday::Response::Middleware
         def on_complete(env)
           unless env.response_headers['Ably-Middleware-Parsed'] == true
-            raise Ably::Exceptions::InvalidResponseBody,
-                  "Content Type #{env.response_headers['Content-Type']} is not supported by this client library"
+            unless  (500..599).include?(env.status)
+              raise Ably::Exceptions::InvalidResponseBody,
+                    "Content Type #{env.response_headers['Content-Type']} is not supported by this client library"
+            end
           end
         end
       end

data/lib/submodules/ably-ruby/lib/ably/rest/presence.rb

@@ -64,6 +64,7 @@ module Ably
         }.merge(options)
 
         [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+        raise ArgumentError, ":end must be equal to or after :start" if options[:start] && options[:end] && (options[:start] > options[:end])
 
         paginated_options = {
           coerce_into: 'Ably::Models::PresenceMessage',

data/lib/submodules/ably-ruby/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = '0.8.2'
+  VERSION = '0.8.3'
 end

data/lib/submodules/ably-ruby/spec/acceptance/realtime/auth_spec.rb

@@ -0,0 +1,242 @@
+# encoding: utf-8
+require 'spec_helper'
+
+# Very high level test coverage of the Realtime::Auth object which is just an async
+# wrapper around the Ably::Auth object
+#
+describe Ably::Realtime::Auth, :event_machine do
+  vary_by_protocol do
+    let(:default_options) { { key: api_key, environment: environment, protocol: protocol } }
+    let(:client_options)  { default_options }
+    let(:client)          { Ably::Realtime::Client.new(client_options) }
+    let(:auth)            { client.auth }
+
+    context 'with basic auth' do
+      context '#authentication_security_requirements_met?' do
+        before do
+          expect(client.use_tls?).to eql(true)
+        end
+
+        it 'returns true' do
+          expect(auth.authentication_security_requirements_met?).to eql(true)
+          stop_reactor
+        end
+      end
+
+      context '#key' do
+        it 'contains the API key' do
+          expect(auth.key).to eql(api_key)
+          stop_reactor
+        end
+      end
+
+      context '#key_name' do
+        it 'contains the API key name' do
+          expect(auth.key_name).to eql(key_name)
+          stop_reactor
+        end
+      end
+
+      context '#key_secret' do
+        it 'contains the API key secret' do
+          expect(auth.key_secret).to eql(key_secret)
+          stop_reactor
+        end
+      end
+
+      context '#using_basic_auth?' do
+        it 'is true when using Basic Auth' do
+          expect(auth).to be_using_basic_auth
+          stop_reactor
+        end
+      end
+
+      context '#using_token_auth?' do
+        it 'is false when using Basic Auth' do
+          expect(auth).to_not be_using_token_auth
+          stop_reactor
+        end
+      end
+    end
+
+    context 'with token auth' do
+      let(:client_id)      { random_str }
+      let(:client_options) { default_options.merge(client_id: client_id) }
+
+      context '#client_id' do
+        it 'contains the ClientOptions client ID' do
+          expect(auth.client_id).to eql(client_id)
+          stop_reactor
+        end
+      end
+
+      context '#token' do
+        let(:client_options) { default_options.merge(token: random_str) }
+
+        it 'contains the current token after auth' do
+          expect(auth.token).to_not be_nil
+          stop_reactor
+        end
+      end
+
+      context '#current_token_details' do
+        it 'contains the current token after auth' do
+          expect(auth.current_token_details).to be_nil
+          auth.authorise do
+            expect(auth.current_token_details).to be_a(Ably::Models::TokenDetails)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#token_renewable?' do
+        it 'is true when an API key exists' do
+          expect(auth).to be_token_renewable
+          stop_reactor
+        end
+      end
+
+      context '#options (auth_options)' do
+        let(:auth_url) { "https://echo.ably.io/?type=text" }
+        let(:auth_params) { { :body => random_str } }
+
+        it 'contains the configured auth options' do
+          auth.authorise(auth_url: auth_url, auth_params: auth_params) do
+            expect(auth.options[:auth_url]).to eql(auth_url)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#token_params' do
+        let(:custom_ttl) { 33 }
+
+        it 'contains the configured auth options' do
+          auth.authorise({}, ttl: custom_ttl) do
+            expect(auth.token_params[:ttl]).to eql(custom_ttl)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#using_basic_auth?' do
+        it 'is false when using Token Auth' do
+          auth.authorise do
+            expect(auth).to_not be_using_basic_auth
+            stop_reactor
+          end
+        end
+      end
+
+      context '#using_token_auth?' do
+        it 'is true when using Token Auth' do
+          auth.authorise do
+            expect(auth).to be_using_token_auth
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context do
+      let(:custom_ttl)       { 33 }
+      let(:custom_client_id) { random_str }
+
+      context '#create_token_request' do
+        it 'returns a token request asynchronously' do
+          auth.create_token_request({}, { ttl: custom_ttl }) do |token_request|
+            expect(token_request).to be_a(Ably::Models::TokenRequest)
+            expect(token_request.ttl).to eql(custom_ttl)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#create_token_request_async' do
+        it 'returns a token request synchronously' do
+          auth.create_token_request_sync(token_params: { ttl: custom_ttl }).tap do |token_request|
+            expect(token_request).to be_a(Ably::Models::TokenRequest)
+            expect(token_request.ttl).to eql(custom_ttl)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#request_token' do
+        it 'returns a token asynchronously' do
+          auth.request_token({ client_id: custom_client_id }, ttl: custom_ttl) do |token_details|
+            expect(token_details).to be_a(Ably::Models::TokenDetails)
+            expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
+            expect(token_details.client_id).to eql(custom_client_id)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#request_token_async' do
+        it 'returns a token synchronously' do
+          auth.request_token_sync(client_id: custom_client_id, token_params: { ttl: custom_ttl }).tap do |token_details|
+            expect(token_details).to be_a(Ably::Models::TokenDetails)
+            expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
+            expect(token_details.client_id).to eql(custom_client_id)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#authorise' do
+        it 'returns a token asynchronously' do
+          auth.authorise({ client_id: custom_client_id }, ttl: custom_ttl) do |token_details|
+            expect(token_details).to be_a(Ably::Models::TokenDetails)
+            expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
+            expect(token_details.client_id).to eql(custom_client_id)
+            stop_reactor
+          end
+        end
+      end
+
+      context '#authorise_async' do
+        it 'returns a token synchronously' do
+          auth.authorise_sync(client_id: custom_client_id, token_params: { ttl: custom_ttl }).tap do |token_details|
+            expect(auth.authorise_sync).to be_a(Ably::Models::TokenDetails)
+            expect(token_details.expires.to_i).to be_within(3).of(Time.now.to_i + custom_ttl)
+            expect(token_details.client_id).to eql(custom_client_id)
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context '#auth_params' do
+      it 'returns the auth params asynchronously' do
+        auth.auth_params do |auth_params|
+          expect(auth_params).to be_a(Hash)
+          stop_reactor
+        end
+      end
+    end
+
+    context '#auth_params' do
+      it 'returns the auth params synchronously' do
+        expect(auth.auth_params_sync).to be_a(Hash)
+        stop_reactor
+      end
+    end
+
+    context '#auth_header' do
+      it 'returns an auth header asynchronously' do
+        auth.auth_header do |auth_header|
+          expect(auth_header).to be_a(String)
+          stop_reactor
+        end
+      end
+    end
+
+    context '#auth_header' do
+      it 'returns an auth header synchronously' do
+        expect(auth.auth_header_sync).to be_a(String)
+        stop_reactor
+      end
+    end
+  end
+end