ably 0.1.4 → 0.1.5

data/lib/ably/rest/client.rb

@@ -1,8 +1,8 @@
-require "json"
-require "faraday"
+require 'faraday'
+require 'json'
+require 'logger'
 
-require "ably/rest/middleware/exceptions"
-require "ably/rest/middleware/parse_json"
+require 'ably/rest/middleware/exceptions'
 
 module Ably
   module Rest
@@ -25,17 +25,18 @@ module Ably
 
       DOMAIN = "rest.ably.io"
 
-      attr_reader :tls, :environment, :auth, :channels
+      attr_reader :tls, :environment, :protocol, :auth, :channels, :log_level
       def_delegators :auth, :client_id, :auth_options
 
       # 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
       # @option options (see Ably::Auth#authorise)
-      # @option options [Boolean] :tls          TLS is used by default, providing a value of false disbles TLS.  Please note Basic Auth is disallowed without TLS as secrets cannot be transmitted over unsecured connections.
-      # @option options [String]  :api_key      API key comprising the key ID and key secret in a single string
-      # @option options [String]  :environment  Specify 'sandbox' when testing the client library against an alternate Ably environment
-      # @option options [Boolean] :debug_http   Send HTTP debugging information from Faraday for all HTTP requests to STDOUT
+      # @option options [Boolean]           :tls          TLS is used by default, providing a value of false disbles TLS.  Please note Basic Auth is disallowed without TLS as secrets cannot be transmitted over unsecured connections.
+      # @option options [String]            :api_key      API key comprising the key ID and key secret in a single string
+      # @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 [Logger::Severity]  :log_level    Log level for the standard Logger that outputs to STDOUT.  Defaults to Logger::WARN, can be set to Logger::FATAL, Logger::ERROR, Logger::WARN, Logger::INFO, Logger::DEBUG
       #
       # @yield (see Ably::Auth#authorise)
       # @yieldparam (see Ably::Auth#authorise)
@@ -59,7 +60,11 @@ module Ably
 
         @tls                 = options.delete(:tls) == false ? false : true
         @environment         = options.delete(:environment) # nil is production
+        @protocol            = options.delete(:protocol) || :json # TODO: Default to :msgpack when protocol MsgPack support added
         @debug_http          = options.delete(:debug_http)
+        @log_level           = options.delete(:log_level) || Logger::WARN
+
+        raise ArgumentError, 'Protocol is invalid.  Must be either :msgpack or :json' unless [:msgpack, :json].include?(@protocol)
 
         @auth     = Auth.new(self, options, &auth_block)
         @channels = Ably::Rest::Channels.new(self)
@@ -85,7 +90,9 @@ module Ably
 
         response = get("/stats", default_params.merge(params))
 
-        response.body
+        response.body.map do |stat|
+          IdiomaticRubyWrapper(stat)
+        end
       end
 
       # Return the Ably service time
@@ -128,11 +135,22 @@ module Ably
         )
       end
 
-      # When true, will send HTTP debugging information from Faraday for all HTTP requests to STDOUT
+      def logger
+        @logger ||= Logger.new(STDOUT).tap do |logger|
+          logger.level = log_level
+        end
+      end
+
+      # Mime type used for HTTP requests
       #
-      # @return [Boolean]
-      def debug_http?
-        !!@debug_http
+      # @return [String]
+      def mime_type
+        case protocol
+        when :json
+          'application/json'
+        else
+          'application/x-msgpack'
+        end
       end
 
       private
@@ -175,7 +193,7 @@ module Ably
         @connection_options ||= {
           builder: middleware,
           headers: {
-            accept:     "application/json",
+            accept:     mime_type,
             user_agent: user_agent
           },
           request: {
@@ -190,18 +208,16 @@ module Ably
       # @see http://mislav.uniqpath.com/2011/07/faraday-advanced-http/
       def middleware
         @middleware ||= Faraday::RackBuilder.new do |builder|
-          # Convert request params to "www-form-urlencoded"
-          builder.use Faraday::Request::UrlEncoded
-
-          # Parse JSON response bodies
-          builder.use Ably::Rest::Middleware::ParseJson
-
-          # Log HTTP requests if debug_http option set
-          builder.response :logger if @debug_http
+          setup_middleware builder
 
           # Raise exceptions if response code is invalid
           builder.use Ably::Rest::Middleware::Exceptions
 
+
+          # Log HTTP requests if log level is DEBUG option set
+          builder.response :logger if log_level == Logger::DEBUG
+
+
           # Set Faraday's HTTP adapter
           builder.adapter Faraday.default_adapter
         end

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

@@ -1,4 +1,4 @@
-require "json"
+require 'faraday'
 
 module Ably
   module Rest

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

@@ -1,13 +1,18 @@
-require "json"
+require 'faraday'
+require 'json'
 
 module Ably
   module Rest
     module Middleware
       class ParseJson < Faraday::Response::Middleware
+        def on_complete(env)
+          env.body = parse(env.body) unless env.response_headers['Ably-Middleware-Parsed'] == true
+        end
+
         def parse(body)
           JSON.parse(body)
         rescue JSON::ParserError => e
-          raise Ably::Exceptions::InvalidResponseBody, "Expected JSON response. #{e.message}"
+          raise Ably::Exceptions::InvalidResponseBody, "Expected JSON response: #{e.message}"
         end
       end
     end

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

@@ -0,0 +1,23 @@
+require 'faraday'
+require 'msgpack'
+
+module Ably
+  module Rest
+    module Middleware
+      class ParseMessagePack < Faraday::Response::Middleware
+        def on_complete(env)
+          if env.response_headers['Content-Type'] == 'application/x-msgpack'
+            env.body = parse(env.body)
+            env.response_headers['Ably-Middleware-Parsed'] = true
+          end
+        end
+
+        def parse(body)
+          MessagePack.unpack(body)
+        rescue MessagePack::MalformedFormatError => e
+          raise Ably::Exceptions::InvalidResponseBody, "Expected MessagePack response: #{e.message}"
+        end
+      end
+    end
+  end
+end

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

@@ -13,15 +13,15 @@ module Ably::Rest::Models
     # @option options [Symbol,String] :coerce_into symbol or string representing class that should be used to create each item in the PagedResource
     #
     # @return [PagedResource]
-    def initialize(http_response, base_url, client, coerce_into: nil)
+    def initialize(http_response, base_url, client, options = {})
       @http_response = http_response
       @client        = client
       @base_url      = "#{base_url.gsub(%r{/[^/]*$}, '')}/"
-      @coerce_into   = coerce_into
+      @coerce_into   = options[:coerce_into]
 
-      @body = if coerce_into
+      @body = if @coerce_into
         http_response.body.map do |item|
-          Kernel.const_get(coerce_into).new(item)
+          Kernel.const_get(@coerce_into).new(item)
         end
       else
         http_response.body

data/lib/ably/util/pub_sub.rb

@@ -0,0 +1,32 @@
+module Ably::Util
+  # PubSub class provides methods to publish & subscribe to events, with methods and naming
+  # intentionally different to EventEmitter as it is intended for private message handling
+  # within the client library.
+  #
+  # @example
+  #   class Channel
+  #     def messages
+  #       @messages ||= PubSub.new
+  #     end
+  #   end
+  #
+  #   channel = Channel.new
+  #   channel.messages.subscribe(:event) { |name| puts "Event message #{name} received" }
+  #   channel.messages.publish :event, "Test"
+  #   #=> "Event message Test received"
+  #   channel.messages.remove :event
+  #
+  class PubSub
+    include Ably::Modules::EventEmitter
+
+    def initialize(options = {})
+      self.class.instance_eval do
+        configure_event_emitter options
+
+        alias_method :subscribe, :on
+        alias_method :publish, :trigger
+        alias_method :unsubscribe, :off
+      end
+    end
+  end
+end

data/lib/ably/version.rb

@@ -1,3 +1,3 @@
 module Ably
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/spec/acceptance/realtime/channel_spec.rb

@@ -17,6 +17,7 @@ describe Ably::Realtime::Channel do
       channel = client.channel(channel_name)
       channel.attach
       channel.on(:attached) do
+        expect(channel.state).to eq(:attached)
         attached = true
         stop_reactor
       end

data/spec/acceptance/realtime/message_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe 'Ably::Realtime::Channel Messages' do
+  include RSpec::EventMachine
+
+  let(:client) do
+    Ably::Realtime::Client.new(options.merge(api_key: api_key, environment: environment))
+  end
+  let(:channel) { client.channel(channel_name) }
+
+  let(:other_client) do
+    Ably::Realtime::Client.new(options.merge(api_key: api_key, environment: environment))
+  end
+  let(:other_client_channel) { other_client.channel(channel_name) }
+
+  context 'using binary protocol' do
+    skip 'sends a string message'
+    skip 'sends a single message with an echo on another connection'
+    skip 'all tests with multiple messages'
+  end
+
+  context 'using text protocol' do
+    let(:channel_name) { 'subscribe_send_text' }
+    let(:options) { { :protocol => :json } }
+    let(:payload) { 'Test message (subscribe_send_text)' }
+
+    it 'sends a string message' do
+      run_reactor do
+        channel.attach
+        channel.on(:attached) do
+          channel.publish('test_event', payload) do |message|
+            expect(message.data).to eql(payload)
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    it 'sends a single message with an echo on another connection' do
+      run_reactor do
+        other_client_channel.attach
+        other_client_channel.on(:attached) do
+          channel.publish 'test_event', payload
+          other_client_channel.subscribe('test_event') do |message|
+            expect(message.data).to eql(payload)
+            stop_reactor
+          end
+        end
+      end
+    end
+
+    context 'with multiple messages' do
+      let(:send_count) { 15 }
+      let(:expected_echos) { send_count * 2 }
+      let(:channel_name) { SecureRandom.hex }
+      let(:echos) do
+        { client: 0, other: 0 }
+      end
+      let(:callbacks) do
+        { client: 0, other: 0 }
+      end
+
+      def expect_messages_to_be_echoed_on_both_connections
+        {
+          channel              => :client,
+          other_client_channel => :other
+        }.each do |target_channel, echo_key|
+          EventMachine.defer do
+            target_channel.subscribe('test_event') do |message|
+              echos[echo_key] += 1
+
+              if echos[:client] == expected_echos && echos[:other] == expected_echos
+                # Wait briefly before doing the final check in case additional messages received
+                EventMachine.add_timer(0.5) do
+                  expect(echos[:client]).to eql(expected_echos)
+                  expect(echos[:other]).to eql(expected_echos)
+                  expect(callbacks[:client]).to eql(send_count)
+                  expect(callbacks[:other]).to eql(send_count)
+                  stop_reactor
+                end
+              end
+            end
+          end
+        end
+      end
+
+      it 'sends and receives the messages on both opened connections (4 x send count due to local echos) and calls the callbacks' do
+        run_reactor(10) do
+          channel.attach
+          other_client_channel.attach
+
+          channel.on(:attached) do
+            other_client_channel.on(:attached) do
+              send_count.times do |index|
+                channel.publish('test_event', "#{index}: #{payload}") do
+                  callbacks[:client] += 1
+                end
+                other_client_channel.publish('test_event', "#{index}: #{payload}") do
+                  callbacks[:other] += 1
+                end
+              end
+              expect_messages_to_be_echoed_on_both_connections
+            end
+          end
+        end
+      end
+    end
+
+    context 'without suitable publishing permissions' do
+      let(:restricted_client) do
+        Ably::Realtime::Client.new(options.merge(api_key: restricted_api_key, environment: environment))
+      end
+      let(:restricted_channel) { restricted_client.channel(channel_name) }
+      let(:payload) { 'Test message without permission to publish' }
+
+      it 'calls the error callback' do
+        run_reactor do
+          restricted_channel.attach
+          restricted_channel.on(:attached) do
+            deferrable = restricted_channel.publish('test_event', payload)
+            deferrable.errback do |message, error|
+              expect(message.data).to eql(payload)
+              expect(error.status).to eql(401)
+              stop_reactor
+            end
+            deferrable.callback do |message|
+              fail 'Success callback should not have been called'
+              stop_reactor
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/rest/base_spec.rb

@@ -6,9 +6,59 @@ describe "REST" do
     Ably::Rest::Client.new(api_key: api_key, environment: environment)
   end
 
+  describe "protocol" do
+    include Ably::Modules::Conversions
+
+    let(:client_options) { {} }
+    let(:client) do
+      Ably::Rest::Client.new(client_options.merge(api_key: 'appid.keyuid:keysecret'))
+    end
+
+    skip '#protocol should default to :msgpack'
+
+    context 'transport' do
+      let(:now) { Time.now - 1000 }
+      let(:body_value) { [as_since_epoch(now)] }
+
+      before do
+        stub_request(:get, "#{client.endpoint}/time").
+          with(:headers => { 'Accept' => mime }).
+          to_return(:status => 200, :body => request_body, :headers => { 'Content-Type' => mime })
+      end
+
+      context 'when protocol is set as :json' do
+        let(:client_options) { { protocol: :json } }
+        let(:mime) { 'application/json' }
+        let(:request_body) { body_value.to_json }
+
+        it 'uses JSON', webmock: true do
+          expect(client.protocol).to eql(:json)
+          expect(client.time).to be_within(1).of(now)
+        end
+
+        skip 'uses JSON against Ably service for Auth'
+        skip 'uses JSON against Ably service for Messages'
+      end
+
+      context 'when protocol is set as :msgpack' do
+        let(:client_options) { { protocol: :msgpack } }
+        let(:mime) { 'application/x-msgpack' }
+        let(:request_body) { body_value.to_msgpack }
+
+        it 'uses MsgPack', webmock: true do
+          expect(client.protocol).to eql(:msgpack)
+          expect(client.time).to be_within(1).of(now)
+        end
+
+        skip 'uses MsgPack against Ably service for Auth'
+        skip 'uses MsgPack against Ably service for Messages'
+      end
+    end
+  end
+
   describe "invalid requests in middleware" do
     it "should raise an InvalidRequest exception with a valid message" do
-      invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret')
+      invalid_client = Ably::Rest::Client.new(api_key: 'appid.keyuid:keysecret', environment: environment)
       expect { invalid_client.channel('test').publish('foo', 'choo') }.to raise_error do |error|
         expect(error).to be_a(Ably::Exceptions::InvalidRequest)
         expect(error.message).to match(/invalid credentials/)

data/spec/acceptance/rest/presence_spec.rb

@@ -45,12 +45,17 @@ describe "REST" do
   describe "options" do
     let(:channel_name) { "persisted:#{SecureRandom.hex(4)}" }
     let(:presence) { client.channel(channel_name).presence }
+    let(:user) { 'appid.keyuid' }
+    let(:secret) { SecureRandom.hex(8) }
     let(:endpoint) do
       client.endpoint.tap do |client_end_point|
-        client_end_point.user = key_id
-        client_end_point.password = key_secret
+        client_end_point.user = user
+        client_end_point.password = secret
       end
     end
+    let(:client) do
+      Ably::Rest::Client.new(api_key: "#{user}:#{secret}")
+    end
 
     [:start, :end].each do |option|
       describe ":{option}", webmock: true do