scout 5.7.1 → 5.7.2.pre

data/vendor/pusher/lib/pusher/request.rb

@@ -0,0 +1,107 @@
+require 'signature'
+require 'digest/md5'
+require 'multi_json'
+
+module Pusher
+  class Request
+    attr_reader :body, :params
+
+    def initialize(client, verb, uri, params, body = nil)
+      @client, @verb, @uri = client, verb, uri
+      @head = {}
+
+      @body = body
+      if body
+        params[:body_md5] = Digest::MD5.hexdigest(body)
+        @head['Content-Type'] = 'application/json'
+      end
+
+      request = Signature::Request.new(verb.to_s.upcase, uri.path, params)
+      request.sign(client.authentication_token)
+      @params = request.signed_params
+    end
+
+    def send_sync
+      http = @client.sync_http_client
+
+      begin
+        response = http.request(@verb, @uri, @params, @body, @head)
+      rescue HTTPClient::BadResponseError, HTTPClient::TimeoutError,
+             SocketError, Errno::ECONNREFUSED => e
+        error = Pusher::HTTPError.new("#{e.message} (#{e.class})")
+        error.original_error = e
+        raise error
+      end
+
+      body = response.body ? response.body.chomp : nil
+
+      return handle_response(response.code.to_i, body)
+    end
+
+    def send_async
+      if defined?(EventMachine) && EventMachine.reactor_running?
+        http_client = @client.em_http_client(@uri)
+        df = EM::DefaultDeferrable.new
+
+        http = case @verb
+        when :post
+          http_client.post({
+            :query => @params, :body => @body, :head => @head
+          })
+        when :get
+          http_client.get({
+            :query => @params, :head => @head
+          })
+        else
+          raise "Unsuported verb"
+        end
+        http.callback {
+          begin
+            df.succeed(handle_response(http.response_header.status, http.response.chomp))
+          rescue => e
+            df.fail(e)
+          end
+        }
+        http.errback { |e|
+          message = "Network error connecting to pusher (#{http.error})"
+          Pusher.logger.debug(message)
+          df.fail(Error.new(message))
+        }
+
+        return df
+      else
+        http = @client.sync_http_client
+
+        return http.request_async(@verb, @uri, @params, @body, @head)
+      end
+    end
+
+    private
+
+    def handle_response(status_code, body)
+      case status_code
+      when 200
+        return symbolize_first_level(MultiJson.decode(body))
+      when 202
+        return true
+      when 400
+        raise Error, "Bad request: #{body}"
+      when 401
+        raise AuthenticationError, body
+      when 404
+        raise Error, "404 Not found (#{@uri.path})"
+      when 407
+        raise Error, "Proxy Authentication Required"
+      else
+        raise Error, "Unknown error (status code #{status_code}): #{body}"
+      end
+    end
+
+    def symbolize_first_level(hash)
+      hash.inject({}) do |result, (key, value)|
+        result[key.to_sym] = value
+        result
+      end
+    end
+  end
+end

data/vendor/pusher/lib/pusher/resource.rb

@@ -0,0 +1,36 @@
+module Pusher
+  class Resource
+    def initialize(client, path)
+      @client = client
+      @path = path
+    end
+
+    def get(params)
+      create_request(:get, params).send_sync
+    end
+
+    def get_async(params)
+      create_request(:get, params).send_async
+    end
+
+    def post(params)
+      body = MultiJson.encode(params)
+      create_request(:post, {}, body).send_sync
+    end
+
+    def post_async(params)
+      body = MultiJson.encode(params)
+      create_request(:post, {}, body).send_async
+    end
+
+    private
+
+    def create_request(verb, params, body = nil)
+      Request.new(@client, verb, url, params, body)
+    end
+
+    def url
+      @_url ||= @client.url(@path)
+    end
+  end
+end

data/vendor/pusher/lib/pusher/webhook.rb

@@ -0,0 +1,110 @@
+require 'multi_json'
+require 'openssl'
+
+module Pusher
+  # Used to parse and authenticate WebHooks
+  #
+  # @example Sinatra
+  #   post '/webhooks' do
+  #     webhook = Pusher::WebHook.new(request)
+  #     if webhook.valid?
+  #       webhook.events.each do |event|
+  #         case event["name"]
+  #         when 'channel_occupied'
+  #           puts "Channel occupied: #{event["channel"]}"
+  #         when 'channel_vacated'
+  #           puts "Channel vacated: #{event["channel"]}"
+  #         end
+  #       end
+  #     else
+  #       status 401
+  #     end
+  #     return
+  #   end
+  #
+  class WebHook
+    attr_reader :key, :signature
+
+    # Provide either a Rack::Request or a Hash containing :key, :signature,
+    # :body, and :content_type (optional)
+    #
+    def initialize(request, client = Pusher)
+      @client = client
+      # Should work without Rack
+      if defined?(Rack::Request) && request.kind_of?(Rack::Request)
+        @key = request.env['HTTP_X_PUSHER_KEY']
+        @signature = request.env["HTTP_X_PUSHER_SIGNATURE"]
+        @content_type = request.content_type
+
+        request.body.rewind
+        @body = request.body.read
+        request.body.rewind
+      else
+        @key, @signature, @body = request.values_at(:key, :signature, :body)
+        @content_type = request[:content_type] || 'application/json'
+      end
+    end
+
+    # Returns whether the WebHook is valid by checking that the signature
+    # matches the configured key & secret. In the case that the webhook is
+    # invalid, the reason is logged
+    #
+    # @param extra_tokens [Hash] If you have extra tokens for your Pusher app, you can specify them so that they're used to attempt validation.
+    #
+    def valid?(extra_tokens = nil)
+      extra_tokens = [extra_tokens] if extra_tokens.kind_of?(Hash)
+      if @key == @client.key
+        return check_signature(@client.secret)
+      elsif extra_tokens
+        extra_tokens.each do |token|
+          return check_signature(token[:secret]) if @key == token[:key]
+        end
+      end
+      Pusher.logger.warn "Received webhook with unknown key: #{key}"
+      return false
+    end
+
+    # Array of events (as Hashes) contained inside the webhook
+    #
+    def events
+      data["events"]
+    end
+
+    # The time at which the WebHook was initially triggered by Pusher, i.e.
+    # when the event occurred
+    #
+    # @return [Time]
+    #
+    def time
+      Time.at(data["time_ms"].to_f/1000)
+    end
+
+    # Access the parsed WebHook body
+    #
+    def data
+      @data ||= begin
+        case @content_type
+        when 'application/json'
+          MultiJson.decode(@body)
+        else
+          raise "Unknown Content-Type (#{@content_type})"
+        end
+      end
+    end
+
+    private
+
+    # Checks signature against secret and returns boolean
+    #
+    def check_signature(secret)
+      digest = OpenSSL::Digest::SHA256.new
+      expected = OpenSSL::HMAC.hexdigest(digest, secret, @body)
+      if @signature == expected
+        return true
+      else
+        Pusher.logger.warn "Received WebHook with invalid signature: got #{@signature}, expected #{expected}"
+        return false
+      end
+    end
+  end
+end

data/vendor/{pusher-gem → pusher}/pusher.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "pusher"
-  s.version     = "0.8.4"
+  s.version     = "0.12.0"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Pusher"]
   s.email       = ["support@pusher.com"]
@@ -12,14 +12,15 @@ Gem::Specification.new do |s|
   s.description = %q{Wrapper for pusher.com REST api}
 
   s.add_dependency "multi_json", "~> 1.0"
-  s.add_dependency "crack",     "~> 0.1.0"
-  s.add_dependency "ruby-hmac", "~> 0.4.0"
-  s.add_dependency 'signature', "~> 0.1.2"
+  s.add_dependency 'signature', "~> 0.1.6"
+  s.add_dependency "httpclient", "~> 2.3.0"
+  s.add_dependency "jruby-openssl" if defined?(JRUBY_VERSION)
 
   s.add_development_dependency "rspec", "~> 2.0"
   s.add_development_dependency "webmock"
-  s.add_development_dependency "em-http-request", "~> 1.0.0"
+  s.add_development_dependency "em-http-request", "~> 1.1.0"
   s.add_development_dependency "rake"
+  s.add_development_dependency "rack"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/vendor/pusher/spec/channel_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Pusher::Channel do
+  before do
+    @client = Pusher::Client.new({
+      :app_id => '20',
+      :key => '12345678900000001',
+      :secret => '12345678900000001',
+      :host => 'api.pusherapp.com',
+      :port => 80,
+    })
+    @channel = @client['test_channel']
+  end
+
+  let(:pusher_url_regexp) { %r{/apps/20/events} }
+
+  def stub_post(status, body = nil)
+    options = {:status => status}
+    options.merge!({:body => body}) if body
+
+    stub_request(:post, pusher_url_regexp).to_return(options)
+  end
+
+  def stub_post_to_raise(e)
+    stub_request(:post, pusher_url_regexp).to_raise(e)
+  end
+
+  describe '#trigger!' do
+    it "should use @client.trigger internally" do
+      @client.should_receive(:trigger)
+      @channel.trigger('new_event', 'Some data')
+    end
+  end
+
+  describe '#trigger' do
+    it "should log failure if error raised in http call" do
+      stub_post_to_raise(HTTPClient::BadResponseError)
+
+      Pusher.logger.should_receive(:error).with("Exception from WebMock (HTTPClient::BadResponseError) (Pusher::HTTPError)")
+      Pusher.logger.should_receive(:debug) #backtrace
+      channel = Pusher::Channel.new(@client.url, 'test_channel', @client)
+      channel.trigger('new_event', 'Some data')
+    end
+
+    it "should log failure if Pusher returns an error response" do
+      stub_post 401, "some signature info"
+      Pusher.logger.should_receive(:error).with("some signature info (Pusher::AuthenticationError)")
+      Pusher.logger.should_receive(:debug) #backtrace
+      channel = Pusher::Channel.new(@client.url, 'test_channel', @client)
+      channel.trigger('new_event', 'Some data')
+    end
+  end
+
+  describe "#trigger_async" do
+    it "should use @client.trigger_async internally" do
+      @client.should_receive(:trigger_async)
+      @channel.trigger_async('new_event', 'Some data')
+    end
+  end
+
+  describe '#info' do
+    it "should call the Client#channel_info" do
+      @client.should_receive(:get).with("/channels/mychannel", anything)
+      @channel = @client['mychannel']
+      @channel.info
+    end
+
+    it "should assemble the requested attribes into the info option" do
+      @client.should_receive(:get).with(anything, {
+        :info => "user_count,connection_count"
+      })
+      @channel = @client['presence-foo']
+      @channel.info(%w{user_count connection_count})
+    end
+  end
+
+  describe "#authentication_string" do
+    def authentication_string(*data)
+      lambda { @channel.authentication_string(*data) }
+    end
+
+    it "should return an authentication string given a socket id" do
+      auth = @channel.authentication_string('socketid')
+
+      auth.should == '12345678900000001:827076f551e22451357939e4c7bb1200de29f921d5bf80b40d71668f9cd61c40'
+    end
+
+    it "should raise error if authentication is invalid" do
+      [nil, ''].each do |invalid|
+        authentication_string(invalid).should raise_error Pusher::Error
+      end
+    end
+
+    describe 'with extra string argument' do
+      it 'should be a string or nil' do
+        authentication_string('socketid', 123).should raise_error Pusher::Error
+        authentication_string('socketid', {}).should raise_error Pusher::Error
+
+        authentication_string('socketid', 'boom').should_not raise_error
+        authentication_string('socketid', nil).should_not raise_error
+      end
+
+      it "should return an authentication string given a socket id and custom args" do
+        auth = @channel.authentication_string('socketid', 'foobar')
+
+        auth.should == "12345678900000001:#{hmac(@client.secret, "socketid:test_channel:foobar")}"
+      end
+    end
+  end
+
+  describe '#authenticate' do
+    before :each do
+      @custom_data = {:uid => 123, :info => {:name => 'Foo'}}
+    end
+
+    it 'should return a hash with signature including custom data and data as json string' do
+      MultiJson.stub(:encode).with(@custom_data).and_return 'a json string'
+
+      response = @channel.authenticate('socketid', @custom_data)
+
+      response.should == {
+        :auth => "12345678900000001:#{hmac(@client.secret, "socketid:test_channel:a json string")}",
+        :channel_data => 'a json string'
+      }
+    end
+  end
+end

data/vendor/pusher/spec/client_spec.rb

@@ -0,0 +1,464 @@
+require 'spec_helper'
+
+require 'em-http'
+
+describe Pusher do
+  describe 'using multiple Client objects' do
+    before :each do
+      @client1 = Pusher::Client.new
+      @client2 = Pusher::Client.new
+
+      @client1.scheme = 'ws'
+      @client2.scheme = 'wss'
+      @client1.host = 'one'
+      @client2.host = 'two'
+      @client1.port = 81
+      @client2.port = 82
+      @client1.app_id = '1111'
+      @client2.app_id = '2222'
+      @client1.key = 'AAAA'
+      @client2.key = 'BBBB'
+      @client1.secret = 'aaaaaaaa'
+      @client2.secret = 'bbbbbbbb'
+    end
+
+    it "should send scheme messages to different objects" do
+      @client1.scheme.should_not == @client2.scheme
+    end
+
+    it "should send host messages to different objects" do
+      @client1.host.should_not == @client2.host
+    end
+
+    it "should send port messages to different objects" do
+      @client1.port.should_not == @client2.port
+    end
+
+    it "should send app_id messages to different objects" do
+      @client1.app_id.should_not == @client2.app_id
+    end
+
+    it "should send app_id messages to different objects" do
+      @client1.key.should_not == @client2.key
+    end
+
+    it "should send app_id messages to different objects" do
+      @client1.secret.should_not == @client2.secret
+    end
+
+    it "should send app_id messages to different objects" do
+      @client1.authentication_token.key.should_not == @client2.authentication_token.key
+      @client1.authentication_token.secret.should_not == @client2.authentication_token.secret
+    end
+
+    it "should send url messages to different objects" do
+      @client1.url.to_s.should_not == @client2.url.to_s
+      @client1.url = 'ws://one/apps/111'
+      @client2.url = 'wss://two/apps/222'
+      @client1.scheme.should_not == @client2.scheme
+      @client1.host.should_not == @client2.host
+      @client1.app_id.should_not == @client2.app_id
+    end
+
+    it "should send encrypted messages to different objects" do
+      @client1.encrypted = false
+      @client2.encrypted = true
+      @client1.scheme.should_not == @client2.scheme
+      @client1.port.should_not == @client2.port
+    end
+
+    it "should send [] messages to different objects" do
+      @client1['test'].should_not == @client2['test']
+    end
+
+    it "should send http_proxy messages to different objects" do
+      @client1.http_proxy = 'http://oneuser:onepassword@onehost:8080'
+      @client2.http_proxy = 'http://twouser:twopassword@twohost:8880'
+      @client1.http_proxy.should_not == @client2.http_proxy
+    end
+  end
+
+  # The behaviour should be the same when using the Client object, or the
+  # 'global' client delegated through the Pusher class
+  [lambda { Pusher }, lambda { Pusher::Client.new }].each do |client_gen|
+    before :each do
+      @client = client_gen.call
+    end
+
+    describe 'default configuration' do
+      it 'should be preconfigured for api host' do
+        @client.host.should == 'api.pusherapp.com'
+      end
+
+      it 'should be preconfigured for port 80' do
+        @client.port.should == 80
+      end
+
+      it 'should use standard logger if no other logger if defined' do
+        Pusher.logger.debug('foo')
+        Pusher.logger.should be_kind_of(Logger)
+      end
+    end
+
+    describe 'logging configuration' do
+      it "can be configured to use any logger" do
+        logger = double("ALogger")
+        logger.should_receive(:debug).with('foo')
+        Pusher.logger = logger
+        Pusher.logger.debug('foo')
+        Pusher.logger = nil
+      end
+    end
+
+    describe "configuration using url" do
+      it "should be possible to configure everything by setting the url" do
+        @client.url = "test://somekey:somesecret@api.staging.pusherapp.com:8080/apps/87"
+
+        @client.scheme.should == 'test'
+        @client.host.should == 'api.staging.pusherapp.com'
+        @client.port.should == 8080
+        @client.key.should == 'somekey'
+        @client.secret.should == 'somesecret'
+        @client.app_id.should == '87'
+      end
+
+      it "should override scheme and port when setting encrypted=true after url" do
+        @client.url = "http://somekey:somesecret@api.staging.pusherapp.com:8080/apps/87"
+        @client.encrypted = true
+
+        @client.scheme.should == 'https'
+        @client.port.should == 443
+      end
+    end
+
+    describe 'configuring a http proxy' do
+      it "should be possible to configure everything by setting the http_proxy" do
+        @client.http_proxy = 'http://someuser:somepassword@proxy.host.com:8080'
+
+        @client.proxy.should == {:scheme => 'http', :host => 'proxy.host.com', :port => 8080, :user => 'someuser', :password => 'somepassword'}
+      end
+    end
+
+    describe 'when configured' do
+      before :each do
+        @client.app_id = '20'
+        @client.key    = '12345678900000001'
+        @client.secret = '12345678900000001'
+      end
+
+      describe '#[]' do
+        before do
+          @channel = @client['test_channel']
+        end
+
+        it 'should return a channel' do
+          @channel.should be_kind_of(Pusher::Channel)
+        end
+
+        %w{app_id key secret}.each do |config|
+          it "should raise exception if #{config} not configured" do
+            @client.send("#{config}=", nil)
+            lambda {
+              @client['test_channel']
+            }.should raise_error(Pusher::ConfigurationError)
+          end
+        end
+      end
+
+      describe '#channels' do
+        it "should call the correct URL and symbolise response correctly" do
+          api_path = %r{/apps/20/channels}
+          stub_request(:get, api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode('channels' => {
+              "channel1" => {},
+              "channel2" => {}
+            })
+          })
+          @client.channels.should == {
+            :channels => {
+              "channel1" => {},
+              "channel2" => {}
+            }
+          }
+        end
+      end
+
+      describe '#channel_info' do
+        it "should call correct URL and symbolise response" do
+          api_path = %r{/apps/20/channels/mychannel}
+          stub_request(:get, api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({
+              'occupied' => false,
+            })
+          })
+          @client.channel_info('mychannel').should == {
+            :occupied => false,
+          }
+        end
+      end
+
+      describe '#trigger' do
+        before :each do
+          @api_path = %r{/apps/20/events}
+          stub_request(:post, @api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({})
+          })
+        end
+
+        it "should call correct URL" do
+          @client.trigger(['mychannel'], 'event', {'some' => 'data'}).
+            should == {}
+        end
+
+        it "should pass any parameters in the body of the request" do
+          @client.trigger(['mychannel', 'c2'], 'event', {'some' => 'data'}, {
+            :socket_id => "1234"
+          })
+          WebMock.should have_requested(:post, @api_path).with { |req|
+            parsed = MultiJson.decode(req.body)
+            parsed["name"].should == 'event'
+            parsed["channels"].should == ["mychannel", "c2"]
+            parsed["socket_id"].should == '1234'
+          }
+        end
+
+        it "should convert non string data to JSON before posting" do
+          @client.trigger(['mychannel'], 'event', {'some' => 'data'})
+          WebMock.should have_requested(:post, @api_path).with { |req|
+            MultiJson.decode(req.body)["data"].should == '{"some":"data"}'
+          }
+        end
+
+        it "should accept a single channel as well as an array" do
+          @client.trigger('mychannel', 'event', {'some' => 'data'})
+          WebMock.should have_requested(:post, @api_path).with { |req|
+            MultiJson.decode(req.body)["channels"].should == ['mychannel']
+          }
+        end
+      end
+
+      describe '#trigger_async' do
+        before :each do
+          @api_path = %r{/apps/20/events}
+          stub_request(:post, @api_path).to_return({
+            :status => 200,
+            :body => MultiJson.encode({})
+          })
+        end
+
+        it "should call correct URL" do
+          EM.run {
+            @client.trigger_async('mychannel', 'event', {'some' => 'data'}).callback { |r|
+              r.should == {}
+              EM.stop
+            }
+          }
+        end
+
+        it "should pass any parameters in the body of the request" do
+          EM.run {
+            @client.trigger_async('mychannel', 'event', {'some' => 'data'}, {
+              :socket_id => "1234"
+            }).callback {
+              WebMock.should have_requested(:post, @api_path).with { |req|
+                MultiJson.decode(req.body)["socket_id"].should == '1234'
+              }
+              EM.stop
+            }
+          }
+        end
+
+        it "should convert non string data to JSON before posting" do
+          EM.run {
+            @client.trigger_async('mychannel', 'event', {'some' => 'data'}).callback {
+              WebMock.should have_requested(:post, @api_path).with { |req|
+                MultiJson.decode(req.body)["data"].should == '{"some":"data"}'
+              }
+              EM.stop
+            }
+          }
+        end
+      end
+
+      [:get, :post].each do |verb|
+        describe "##{verb}" do
+          before :each do
+            @url_regexp = %r{api.pusherapp.com}
+            stub_request(verb, @url_regexp).
+              to_return(:status => 200, :body => "{}")
+          end
+
+          let(:call_api) { @client.send(verb, '/path') }
+
+          it "should use http by default" do
+            call_api
+            WebMock.should have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
+          end
+
+          it "should use https if configured" do
+            @client.encrypted = true
+            call_api
+            WebMock.should have_requested(verb, %r{https://api.pusherapp.com})
+          end
+
+          it "should format the respose hash with symbols at first level" do
+            stub_request(verb, @url_regexp).to_return({
+              :status => 200,
+              :body => MultiJson.encode({'something' => {'a' => 'hash'}})
+            })
+            call_api.should == {
+              :something => {'a' => 'hash'}
+            }
+          end
+
+          it "should catch all http exceptions and raise a Pusher::HTTPError wrapping the original error" do
+            stub_request(verb, @url_regexp).to_raise(HTTPClient::TimeoutError)
+
+            error = nil
+            begin
+              call_api
+            rescue => e
+              error = e
+            end
+
+            error.class.should == Pusher::HTTPError
+            error.should be_kind_of(Pusher::Error)
+            error.message.should == 'Exception from WebMock (HTTPClient::TimeoutError)'
+            error.original_error.class.should == HTTPClient::TimeoutError
+          end
+
+          it "should raise Pusher::Error if call returns 400" do
+            stub_request(verb, @url_regexp).to_return({:status => 400})
+            lambda { call_api }.should raise_error(Pusher::Error)
+          end
+
+          it "should raise AuthenticationError if pusher returns 401" do
+            stub_request(verb, @url_regexp).to_return({:status => 401})
+            lambda { call_api }.should raise_error(Pusher::AuthenticationError)
+          end
+
+          it "should raise Pusher::Error if pusher returns 404" do
+            stub_request(verb, @url_regexp).to_return({:status => 404})
+            lambda { call_api }.should raise_error(Pusher::Error, '404 Not found (/apps/20/path)')
+          end
+
+          it "should raise Pusher::Error if pusher returns 407" do
+            stub_request(verb, @url_regexp).to_return({:status => 407})
+            lambda { call_api }.should raise_error(Pusher::Error, 'Proxy Authentication Required')
+          end
+
+          it "should raise Pusher::Error if pusher returns 500" do
+            stub_request(verb, @url_regexp).to_return({:status => 500, :body => "some error"})
+            lambda { call_api }.should raise_error(Pusher::Error, 'Unknown error (status code 500): some error')
+          end
+        end
+      end
+
+      describe "async calling without eventmachine" do
+        [[:get, :get_async], [:post, :post_async]].each do |verb, method|
+          describe "##{method}" do
+            before :each do
+              @url_regexp = %r{api.pusherapp.com}
+              stub_request(verb, @url_regexp).
+                to_return(:status => 200, :body => "{}")
+            end
+
+            let(:call_api) {
+              @client.send(method, '/path').tap { |c|
+                # Allow the async thread (inside httpclient) to run
+                while !c.finished?
+                  sleep 0.01
+                end
+              }
+            }
+
+            it "should use http by default" do
+              call_api
+              WebMock.should have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
+            end
+
+            it "should use https if configured" do
+              @client.encrypted = true
+              call_api
+              WebMock.should have_requested(verb, %r{https://api.pusherapp.com})
+            end
+
+            # Note that the raw httpclient connection object is returned and
+            # the response isn't handled (by handle_response) in the normal way.
+            it "should return a httpclient connection object" do
+              connection = call_api
+              connection.finished?.should be_true
+              response = connection.pop
+              response.status.should == 200
+              response.body.read.should == "{}"
+            end
+          end
+        end
+      end
+
+      describe "async calling with eventmachine" do
+        [[:get, :get_async], [:post, :post_async]].each do |verb, method|
+          describe "##{method}" do
+            before :each do
+              @url_regexp = %r{api.pusherapp.com}
+              stub_request(verb, @url_regexp).
+                to_return(:status => 200, :body => "{}")
+            end
+
+            let(:call_api) { @client.send(method, '/path') }
+
+            it "should use http by default" do
+              EM.run {
+                call_api.callback {
+                  WebMock.should have_requested(verb, %r{http://api.pusherapp.com/apps/20/path})
+                  EM.stop
+                }
+              }
+            end
+
+            it "should use https if configured" do
+              EM.run {
+                @client.encrypted = true
+                call_api.callback {
+                  WebMock.should have_requested(verb, %r{https://api.pusherapp.com})
+                  EM.stop
+                }
+              }
+            end
+
+            it "should format the respose hash with symbols at first level" do
+              EM.run {
+                stub_request(verb, @url_regexp).to_return({
+                  :status => 200,
+                  :body => MultiJson.encode({'something' => {'a' => 'hash'}})
+                })
+                call_api.callback { |response|
+                  response.should == {
+                    :something => {'a' => 'hash'}
+                  }
+                  EM.stop
+                }
+              }
+            end
+
+            it "should errback with Pusher::Error on unsuccessful response" do
+              EM.run {
+                stub_request(verb, @url_regexp).to_return({:status => 400})
+
+                call_api.errback { |e|
+                  e.class.should == Pusher::Error
+                  EM.stop
+                }.callback {
+                  fail
+                }
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end