songkick-transport 0.1.0

data/lib/songkick/transport/request.rb

@@ -0,0 +1,83 @@
+module Songkick
+  module Transport
+    
+    class Request
+      attr_accessor :response,
+                    :error
+      
+      attr_reader   :endpoint,
+                    :verb,
+                    :path,
+                    :params,
+                    :headers,
+                    :timeout,
+                    :start_time,
+                    :duration
+      
+      alias :http_method :verb
+      
+      def initialize(endpoint, verb, path, params, headers = {}, timeout = DEFAULT_TIMEOUT, start_time = nil, response = nil, error = nil)
+        @endpoint   = endpoint
+        @verb       = verb.to_s.downcase
+        @path       = path
+        @headers    = headers
+        @params     = params
+        @timeout    = timeout
+        @response   = response
+        @error      = error
+        @start_time = start_time || Time.now
+        @duration   = (Time.now.to_f - start_time.to_f) * 1000
+        @multipart  = Serialization.multipart?(params)
+      end
+      
+      def use_body?
+        USE_BODY.include?(@verb)
+      end
+      
+      def multipart?
+        @multipart
+      end
+      
+      def content_type
+        return nil unless use_body?
+        if @multipart
+          multipart_request[:content_type]
+        else
+          'application/x-www-form-urlencoded'
+        end
+      end
+      
+      def body
+        return nil unless use_body?
+        if @multipart
+          multipart_request[:body]
+        else
+          Serialization.build_query_string(params)
+        end
+      end
+      
+      def url
+        Serialization.build_url(@verb, @endpoint, @path, @params)
+      end
+      
+      def to_s
+        url = Serialization.build_url(@verb, @endpoint, @path, @params, true)
+        command = "#{@verb.upcase} '#{url}'"
+        return command unless use_body?
+        query = Serialization.build_query_string(params, true, true)
+        command << " -H 'Content-Type: #{content_type}'"
+        command << " -d '#{query}'"
+        command
+      end
+      
+    private
+      
+      def multipart_request
+        return nil unless @multipart
+        @multipart_request ||= Serialization.serialize_multipart(params)
+      end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/response.rb

@@ -0,0 +1,45 @@
+module Songkick
+  module Transport
+    
+    class Response
+      def self.process(request, status, headers, body)
+        case status.to_i
+        when 200 then OK.new(status, headers, body)
+        when 201 then Created.new(status, headers, body)
+        when 204 then NoContent.new(status, headers, body)
+        when 409 then UserError.new(status, headers, body)
+        else
+          Transport.logger.warn "Received error code: #{status} -- #{request}"
+          raise HttpError.new(request, status, headers, body)
+        end
+      rescue Yajl::ParseError
+        Transport.logger.warn "Request returned invalid JSON: #{request}"
+        raise Transport::InvalidJSONError, request
+      end
+      
+      attr_reader :data, :headers, :status
+      
+      def initialize(status, headers, body)
+        @data = if body.is_a?(String)
+                  body.strip == '' ? nil : Yajl::Parser.parse(body)
+                else
+                  body
+                end
+        
+        @headers = Headers.new(headers)
+        @status  = status.to_i
+      end
+      
+      def errors
+        data && data['errors']
+      end
+    
+      class OK        < Response ; end
+      class Created   < Response ; end
+      class NoContent < Response ; end
+      class UserError < Response ; end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/serialization.rb

@@ -0,0 +1,79 @@
+module Songkick
+  module Transport
+    module Serialization
+      
+      extend self
+      
+      SANITIZED_VALUE = '[REMOVED]'
+      
+      def build_url(verb, host, path, params, scrub=false)
+        url = host + path
+        return url if USE_BODY.include?(verb)
+        qs  = build_query_string(params, true, scrub)
+        url + (qs == '' ? '' : '?' + qs)
+      end
+      
+      def build_query_string(params, fully_encode = true, sanitize = false)
+        pairs = []
+        each_qs_param('', params) do |key, value|
+          if sanitize and sanitize?(key)
+            value = SANITIZED_VALUE
+          end
+          pairs << [key, value]
+        end
+        if fully_encode
+          pairs.map { |p| p.join('=') }.join('&') 
+        else
+          pairs.inject({}) do |hash, pair|
+            hash[pair.first] = pair.last
+            hash
+          end
+        end
+      end
+      
+      def each_qs_param(prefix, value, &block)
+        case value
+        when Array
+          value.each { |e| each_qs_param(prefix + "[]", e, &block) }
+        when Hash
+          value.each do |k,v|
+            key = (prefix == '') ? CGI.escape(k.to_s) : prefix + "[#{CGI.escape k.to_s}]"
+            each_qs_param(key, v, &block)
+          end
+        when Transport::IO
+          block.call(prefix, value)
+        else
+          block.call(prefix, CGI.escape(value.to_s))
+        end
+      end
+      
+      def multipart?(params)
+        case params
+        when Hash  then params.any? { |k,v| multipart? v }
+        when Array then params.any? { |e|   multipart? e }
+        else Transport::IO === params
+        end
+      end
+      
+      def sanitize?(key)
+        Transport.sanitized_params.any? { |param| param === key }
+      end
+      
+      def serialize_multipart(params, boundary = Multipartable::DEFAULT_BOUNDARY)
+        params = build_query_string(params, false)
+        
+        parts = params.map { |k,v| Parts::Part.new(boundary, k, v) }
+        parts << Parts::EpiloguePart.new(boundary)
+        ios = parts.map { |p| p.to_io }
+        
+        {
+          :content_type   => "multipart/form-data; boundary=#{boundary}",
+          :content_length => parts.inject(0) { |sum,i| sum + i.length }.to_s,
+          :body           => CompositeReadIO.new(*ios).read
+        }
+      end
+      
+    end
+  end
+end
+

data/lib/songkick/transport/timeout_decorator.rb

@@ -0,0 +1,27 @@
+module Songkick
+  module Transport
+    
+    class TimeoutDecorator
+      def initialize(client, timeout)
+        @client  = client
+        @timeout = timeout
+      end
+      
+      HTTP_VERBS.each do |verb|
+        class_eval %{
+          def #{verb}(path, params = {}, headers ={}, timeout = nil)
+            @client.__send__(:#{verb}, path, params, headers, timeout || @timeout)
+          end
+        }
+      end
+    
+    private
+      
+      def method_missing(*args, &block)
+        @client.__send__(*args, &block)
+      end
+    end
+    
+  end
+end
+

data/lib/songkick/transport/upstream_error.rb

@@ -0,0 +1,28 @@
+module Songkick
+  module Transport
+    class UpstreamError < RuntimeError
+      attr_reader :request
+      
+      def initialize(request)
+        @request = request
+      end
+      
+      def message
+        "#{self.class}: #{@request}"
+      end
+      alias :to_s :message
+    end
+
+    class HostResolutionError < UpstreamError
+    end
+    
+    class ConnectionFailedError < UpstreamError
+    end
+    
+    class TimeoutError < UpstreamError
+    end
+    
+    class InvalidJSONError < UpstreamError
+    end
+  end
+end

data/spec/songkick/transport/curb_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Songkick
+  module Transport
+    
+    describe Curb do
+      after do
+        Songkick::Transport::Curb.clear_thread_connection
+      end
+      
+      class FakeCurl
+        attr_writer :url, :timeout
+        attr_reader :on_header, :response_code, :body_str, :headers
+
+        def initialize(options)
+          @error = options[:error]
+          @headers = {}
+        end
+        
+        def http_get
+          raise(@error, "bang") if @error
+        end
+        
+        def reset
+        end
+      end
+      
+      subject{ Curb.new('localhost', :connection => @fake_curl) }
+      let(:request){ Request.new('http://localhost', 'get', '/', {}) }
+
+      def self.it_should_raise(exception)
+        it "should raise error #{exception}" do
+          begin
+            subject.execute_request(request)
+          rescue => e
+            e.class.should == exception
+          end
+        end
+      end
+
+      def self.when_request_raises_the_exception(raised_exception, &block)
+        describe "when request raises a #{raised_exception}" do
+          before(:each) do
+            @fake_curl = FakeCurl.new(:error => raised_exception)
+          end
+          
+          class_exec(&block)
+        end
+      end
+
+      describe "handling errors" do
+        when_request_raises_the_exception(Curl::Err::HostResolutionError)  { it_should_raise(Transport::HostResolutionError)   }
+        when_request_raises_the_exception(Curl::Err::ConnectionFailedError){ it_should_raise(Transport::ConnectionFailedError) }
+        when_request_raises_the_exception(Curl::Err::TimeoutError)         { it_should_raise(Transport::TimeoutError)          }
+        when_request_raises_the_exception(Curl::Err::GotNothingError)      { it_should_raise(Transport::UpstreamError)         }
+      end
+    end
+    
+  end
+end

data/spec/songkick/transport/httparty_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Songkick
+  module Transport
+   
+    describe HttParty do
+      class FakeJSONException < Exception; end
+
+      let(:request){ Request.new('http://localhost', 'get', '/', {}) }
+      
+      describe "handling errors" do
+        class FakeHttparty < Songkick::Transport::HttParty::Adapter
+          class << self
+            attr_accessor :error
+          end
+          
+          def self.get(path, args)
+            raise(error, "bang") if error
+          end
+          
+        end
+        
+        def self.it_should_raise(exception)
+          it "should raise error #{exception}" do
+            begin
+              @httparty.execute_request(request)
+            rescue => e
+              e.class.should == exception
+            end
+          end
+        end
+
+        def self.when_request_raises_the_exception(raised_exception, &block)
+          describe "when request raises a #{raised_exception}" do
+            before(:each) do
+              FakeHttparty.error = raised_exception
+              @httparty = Songkick::Transport::HttParty.new('localhost', {:adapter => FakeHttparty})
+            end
+          
+            class_exec(&block)
+          end
+        end
+
+        describe "handling errors" do
+          when_request_raises_the_exception(FakeJSONException) { it_should_raise(Transport::InvalidJSONError)      }
+          when_request_raises_the_exception(SocketError)       { it_should_raise(Transport::ConnectionFailedError) }
+          when_request_raises_the_exception(Timeout::Error)    { it_should_raise(Transport::TimeoutError)          }
+          when_request_raises_the_exception(UpstreamError)     { it_should_raise(Transport::UpstreamError)         }
+          when_request_raises_the_exception(Exception)         { it_should_raise(Transport::UpstreamError)         }
+        end
+      end
+    end
+    
+  end
+end

data/spec/songkick/transport/request_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe Songkick::Transport::Request do
+  let :params do
+    {:username => "Louis", :password => "CK", :access => {:token => "foo"}}
+  end
+  
+  let :get_request do
+    Songkick::Transport::Request.new("www.example.com", "GET", "/", params)
+  end
+  
+  let :post_request do
+    Songkick::Transport::Request.new("www.example.com", "POST", "/", params)
+  end
+  
+  def query(request, pattern)
+    request.to_s.scan(pattern).flatten.first.split("&").sort
+  end
+  
+  describe :to_s do
+    context "with a get request" do
+      it "returns the request as a curl command" do
+        pattern = %r{^GET 'www.example.com/\?([^']+)'$}
+        get_request.to_s.should =~ pattern
+        query(get_request, pattern).should == ["access[token]=foo", "password=CK", "username=Louis"]
+      end
+    end
+    
+    context "with a post request" do
+      it "returns the request as a curl command" do
+        pattern = %r{^POST 'www.example.com/' -H 'Content-Type: application/x-www-form-urlencoded' -d '([^']+)'$}
+        post_request.to_s.should =~ pattern
+        query(post_request, pattern).should == ["access[token]=foo", "password=CK", "username=Louis"]
+      end
+    end
+    
+    describe "with query sanitization" do
+      before do
+        Songkick::Transport.stub(:sanitized_params).and_return [/password/, "access[token]"]
+      end
+
+      context "with a get request" do
+        it "removes the parameter values from the request" do
+          pattern = %r{^GET 'www.example.com/\?([^']+)'$}
+          get_request.to_s.should =~ pattern
+          query(get_request, pattern).should == ["access[token]=[REMOVED]", "password=[REMOVED]", "username=Louis"]
+        end
+      end
+      
+      context "with a post request" do
+        it "removes the parameter values from the request" do
+          pattern = %r{^POST 'www.example.com/' -H 'Content-Type: application/x-www-form-urlencoded' -d '([^']+)'$}
+          post_request.to_s.should =~ pattern
+          query(post_request, pattern).should == ["access[token]=[REMOVED]", "password=[REMOVED]", "username=Louis"]
+        end
+      end
+    end
+  end
+end
+