pusher 0.10.0 → 0.11.0

data/lib/pusher/query_encoder.rb

@@ -0,0 +1,47 @@
+module Pusher
+  # Query string encoding extracted with thanks from em-http-request
+  module QueryEncoder
+    def encode_query(uri, query)
+      encoded_query = if query.kind_of?(Hash)
+        query.map { |k, v| encode_param(k, v) }.join('&')
+      else
+        query.to_s
+      end
+
+      if uri && !uri.query.to_s.empty?
+        encoded_query = [encoded_query, uri.query].reject {|part| part.empty?}.join("&")
+      end
+      encoded_query.to_s.empty? ? uri.path : "#{uri.path}?#{encoded_query}"
+    end
+
+    # URL encodes query parameters:
+    # single k=v, or a URL encoded array, if v is an array of values
+    def encode_param(k, v)
+      if v.is_a?(Array)
+        v.map { |e| escape(k) + "[]=" + escape(e) }.join("&")
+      else
+        escape(k) + "=" + escape(v)
+      end
+    end
+
+    def escape(s)
+      if defined?(EscapeUtils)
+        EscapeUtils.escape_url(s.to_s)
+      else
+        s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) {
+          '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+        }
+      end
+    end
+
+    if ''.respond_to?(:bytesize)
+      def bytesize(string)
+        string.bytesize
+      end
+    else
+      def bytesize(string)
+        string.size
+      end
+    end
+  end
+end

data/lib/pusher/request.rb

@@ -4,59 +4,12 @@ require 'multi_json'
 
 module Pusher
   class Request
-    # Query string encoding extracted with thanks from em-http-request
-    module QueryEncoder
-      def encode_query(uri, query)
-        encoded_query = if query.kind_of?(Hash)
-          query.map { |k, v| encode_param(k, v) }.join('&')
-        else
-          query.to_s
-        end
-
-        if uri && !uri.query.to_s.empty?
-          encoded_query = [encoded_query, uri.query].reject {|part| part.empty?}.join("&")
-        end
-        encoded_query.to_s.empty? ? uri.path : "#{uri.path}?#{encoded_query}"
-      end
-
-      # URL encodes query parameters:
-      # single k=v, or a URL encoded array, if v is an array of values
-      def encode_param(k, v)
-        if v.is_a?(Array)
-          v.map { |e| escape(k) + "[]=" + escape(e) }.join("&")
-        else
-          escape(k) + "=" + escape(v)
-        end
-      end
-
-      def escape(s)
-        if defined?(EscapeUtils)
-          EscapeUtils.escape_url(s.to_s)
-        else
-          s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) {
-            '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
-          }
-        end
-      end
-
-      if ''.respond_to?(:bytesize)
-        def bytesize(string)
-          string.bytesize
-        end
-      else
-        def bytesize(string)
-          string.size
-        end
-      end
-    end
-
     include QueryEncoder
 
     attr_reader :body, :params
 
-    def initialize(verb, uri, params, body = nil, token = nil, client = Pusher)
-      @verb = verb
-      @uri = uri
+    def initialize(client, verb, uri, params, body = nil)
+      @client, @verb, @uri = client, verb, uri
 
       if body
         @body = body
@@ -64,36 +17,25 @@ module Pusher
       end
 
       request = Signature::Request.new(verb.to_s.upcase, uri.path, params)
-      request.sign(token || client.authentication_token)
+      request.sign(client.authentication_token)
       @params = request.signed_params
     end
 
     def send_sync
-      if ssl?
-        require 'net/https' unless defined?(Net::HTTPS)
-      else
-        require 'net/http' unless defined?(Net::HTTP)
-      end
-
-      @http_sync ||= begin
-        http = Net::HTTP.new(@uri.host, @uri.port)
-        http.use_ssl = true if ssl?
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if ssl?
-        http
-      end
+      http = @client.net_http_client
 
       begin
         case @verb
         when :post
-          response = @http_sync.post(encode_query(@uri, @params), @body, {
+          response = http.post(encode_query(@uri, @params), @body, {
             'Content-Type'=> 'application/json'
           })
         when :get
-          response = @http_sync.get(encode_query(@uri, @params), {
+          response = http.get(encode_query(@uri, @params), {
             'Content-Type'=> 'application/json'
           })
         else
-          raise "Unknown verb"
+          raise "Unsuported verb"
         end
       rescue Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED,
              Errno::ETIMEDOUT, Errno::EHOSTUNREACH,
@@ -111,31 +53,36 @@ module Pusher
     end
 
     def send_async
-      unless defined?(EventMachine) && EventMachine.reactor_running?
-        raise Error, "In order to use trigger_async you must be running inside an eventmachine loop"
+      df = EM::DefaultDeferrable.new
+
+      http_client = @client.em_http_client(@uri)
+      http = case @verb
+      when :post
+        http_client.post({
+          :query => @params, :timeout => 5, :body => @body,
+          :head => {'Content-Type'=> 'application/json'}
+        })
+      when :get
+        http_client.get({
+          :query => @params, :timeout => 5,
+          :head => {'Content-Type'=> 'application/json'}
+        })
+      else
+        raise "Unsuported verb"
       end
-      require 'em-http' unless defined?(EventMachine::HttpRequest)
-
-      deferrable = EM::DefaultDeferrable.new
-
-      http = EventMachine::HttpRequest.new(@uri).post({
-        :query => @params, :timeout => 5, :body => @body,
-        :head => {'Content-Type'=> 'application/json'}
-      })
       http.callback {
         begin
-          handle_response(http.response_header.status, http.response.chomp)
-          deferrable.succeed
+          df.succeed(handle_response(http.response_header.status, http.response.chomp))
         rescue => e
-          deferrable.fail(e)
+          df.fail(e)
         end
       }
       http.errback {
         Pusher.logger.debug("Network error connecting to pusher: #{http.inspect}")
-        deferrable.fail(Error.new("Network error connecting to pusher"))
+        df.fail(Error.new("Network error connecting to pusher"))
       }
 
-      deferrable
+      df
     end
 
     private
@@ -151,16 +98,14 @@ module Pusher
       when 401
         raise AuthenticationError, body
       when 404
-        raise Error, "Resource not found: app_id is probably invalid"
+        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 ssl?
-      @uri.scheme == 'https'
-    end
-
     def symbolize_first_level(hash)
       hash.inject({}) do |result, (key, value)|
         result[key.to_sym] = value

data/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/pusher.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "pusher"
-  s.version     = "0.10.0"
+  s.version     = "0.11.0"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Pusher"]
   s.email       = ["support@pusher.com"]

data/spec/channel_spec.rb

@@ -9,108 +9,26 @@ describe Pusher::Channel do
       :host => 'api.pusherapp.com',
       :port => 80,
     })
-    @client.encrypted = false
     @channel = @client['test_channel']
-
-    WebMock.reset!
-    WebMock.disable_net_connect!
   end
 
-  let(:pusher_url_regexp) { %r{/apps/20/channels/test_channel/events} }
+  let(:pusher_url_regexp) { %r{/apps/20/events} }
 
   def stub_post(status, body = nil)
     options = {:status => status}
     options.merge!({:body => body}) if body
 
-    WebMock.stub_request(:post, pusher_url_regexp).to_return(options)
+    stub_request(:post, pusher_url_regexp).to_return(options)
   end
 
   def stub_post_to_raise(e)
-    WebMock.stub_request(:post, pusher_url_regexp).to_raise(e)
+    stub_request(:post, pusher_url_regexp).to_raise(e)
   end
 
-  describe 'trigger!' do
-    before :each do
-      stub_post 202
-    end
-
-    it 'should configure HTTP library to talk to pusher API' do
-      @channel.trigger!('new_event', 'Some data')
-      WebMock.should have_requested(:post, %r{http://api.pusherapp.com})
-    end
-
-    it "should POST to https api if ssl enabled" do
-      @client.encrypted = true
-      encrypted_channel = Pusher::Channel.new(@client.url, 'test_channel', @client)
-      encrypted_channel.trigger('new_event', 'Some data')
-      WebMock.should have_requested(:post, %r{https://api.pusherapp.com})
-    end
-
-    it 'should POST hashes by encoding as JSON in the request body' do
-      @channel.trigger!('new_event', {
-        :name => 'Pusher',
-        :last_name => 'App'
-      })
-      WebMock.should have_requested(:post, pusher_url_regexp).with { |req|
-        query_hash = req.uri.query_values
-        query_hash["name"].should == 'new_event'
-        query_hash["auth_key"].should == @client.key
-        query_hash["auth_timestamp"].should_not be_nil
-
-        parsed = MultiJson.decode(req.body)
-        parsed.should == {
-          "name" => 'Pusher',
-          "last_name" => 'App'
-        }
-
-        req.headers['Content-Type'].should == 'application/json'
-      }
-    end
-
-    it "should POST string data unmodified in request body" do
-      string = "foo\nbar\""
-      @channel.trigger!('new_event', string)
-      WebMock.should have_requested(:post, pusher_url_regexp).with { |req| req.body.should == "foo\nbar\"" }
-    end
-
-    def trigger
-      lambda { @channel.trigger!('new_event', 'Some data') }
-    end
-
-    it "should catch all Net::HTTP exceptions and raise a Pusher::HTTPError, exposing the original error if required" do
-      stub_post_to_raise Timeout::Error
-      error_raised = nil
-
-      begin
-        trigger.call
-      rescue => e
-        error_raised = e
-      end
-
-      error_raised.class.should == Pusher::HTTPError
-      error_raised.message.should == 'Exception from WebMock (Timeout::Error)'
-      error_raised.original_error.class.should == Timeout::Error
-    end
-
-
-    it "should raise Pusher::Error if pusher returns 400" do
-      stub_post 400
-      trigger.should raise_error(Pusher::Error)
-    end
-
-    it "should raise AuthenticationError if pusher returns 401" do
-      stub_post 401
-      trigger.should raise_error(Pusher::AuthenticationError)
-    end
-
-    it "should raise Pusher::Error if pusher returns 404" do
-      stub_post 404
-      trigger.should raise_error(Pusher::Error, 'Resource not found: app_id is probably invalid')
-    end
-
-    it "should raise Pusher::Error if pusher returns 500" do
-      stub_post 500, "some error"
-      trigger.should raise_error(Pusher::Error, 'Unknown error (status code 500): some error')
+  describe '#trigger!' do
+    it "should use @client.trigger internally" do
+      @client.should_receive(:trigger)
+      @channel.trigger('new_event', 'Some data')
     end
   end
 
@@ -134,70 +52,21 @@ describe Pusher::Channel do
   end
 
   describe "#trigger_async" do
-    it "should by default POST to http api" do
-      EM.run {
-        stub_post 202
-        @channel.trigger_async('new_event', 'Some data').callback {
-          WebMock.should have_requested(:post, %r{http://api.pusherapp.com})
-          EM.stop
-        }
-      }
-    end
-
-    it "should POST to https api if ssl enabled" do
-      @client.encrypted = true
-      EM.run {
-        stub_post 202
-        channel = Pusher::Channel.new(@client.url, 'test_channel', @client)
-        channel.trigger_async('new_event', 'Some data').callback {
-          WebMock.should have_requested(:post, %r{https://api.pusherapp.com})
-          EM.stop
-        }
-      }
-    end
-
-    it "should return a deferrable which succeeds in success case" do
-      stub_post 202
-
-      EM.run {
-        d = @channel.trigger_async('new_event', 'Some data')
-        d.callback {
-          WebMock.should have_requested(:post, pusher_url_regexp)
-          EM.stop
-        }
-        d.errback {
-          fail
-          EM.stop
-        }
-      }
-    end
-
-    it "should return a deferrable which fails (with exception) in fail case" do
-      stub_post 401
-
-      EM.run {
-        d = @channel.trigger_async('new_event', 'Some data')
-        d.callback {
-          fail
-        }
-        d.errback { |error|
-          WebMock.should have_requested(:post, pusher_url_regexp)
-          error.should be_kind_of(Pusher::AuthenticationError)
-          EM.stop
-        }
-      }
+    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(:channel_info).with('mychannel', anything)
+      @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(:channel_info).with(anything, {
+      @client.should_receive(:get).with(anything, {
         :info => "user_count,connection_count"
       })
       @channel = @client['presence-foo']