songkick-transport 1.2.0 → 1.9.0

data/lib/songkick/transport.rb

@@ -9,40 +9,43 @@ module Songkick
     DEFAULT_TIMEOUT = 5
     DEFAULT_FORMAT  = :json
     DEFAULT_USER_ERROR_CODES = [409]
-    
+
     HTTP_VERBS    = %w[options head get patch post put delete]
     USE_BODY      = %w[post put]
     FORM_ENCODING = 'application/x-www-form-urlencoded'
-    
+
     ROOT = File.expand_path('..', __FILE__)
-    
+
     autoload :Serialization,    ROOT + '/transport/serialization'
+    autoload :Authentication,    ROOT + '/transport/authentication'
     autoload :Base,             ROOT + '/transport/base'
     autoload :Curb,             ROOT + '/transport/curb'
     autoload :Headers,          ROOT + '/transport/headers'
-    autoload :HeaderDecorator,  ROOT + '/transport/header_decorator'
     autoload :HttParty,         ROOT + '/transport/httparty'
     autoload :RackTest,         ROOT + '/transport/rack_test'
     autoload :Reporting,        ROOT + '/transport/reporting'
     autoload :Request,          ROOT + '/transport/request'
     autoload :Response,         ROOT + '/transport/response'
-    autoload :TimeoutDecorator, ROOT + '/transport/timeout_decorator'
     autoload :Service,          ROOT + '/transport/service'
 
-    autoload :UpstreamError,        ROOT + '/transport/upstream_error'
-    autoload :HostResolutionError,  ROOT + '/transport/upstream_error'
-    autoload :TimeoutError,         ROOT + '/transport/upstream_error'
-    autoload :ConnectionFailedError,ROOT + '/transport/upstream_error'
-    autoload :InvalidJSONError,     ROOT + '/transport/upstream_error'
-    autoload :HttpError,            ROOT + '/transport/http_error'
+    autoload :UpstreamError,         ROOT + '/transport/upstream_error'
+    autoload :HostResolutionError,   ROOT + '/transport/upstream_error'
+    autoload :TimeoutError,          ROOT + '/transport/upstream_error'
+    autoload :ConnectionFailedError, ROOT + '/transport/upstream_error'
+    autoload :InvalidJSONError,      ROOT + '/transport/upstream_error'
+    autoload :HttpError,             ROOT + '/transport/http_error'
 
     def self.register_parser(content_type, parser)
       @parsers ||= {}
       @parsers[content_type] = parser
     end
 
+    def self.register_default_parser(parser)
+      @default_parser = parser
+    end
+
     def self.parser_for(content_type)
-      parser = @parsers && @parsers[content_type]
+      parser = (@parsers && @parsers[content_type]) || @default_parser
       unless parser
         raise TypeError, "Could not find a parser for content-type: #{content_type}"
       end
@@ -50,52 +53,51 @@ module Songkick
     end
 
     register_parser 'application/json', Yajl::Parser
-    
+
     IO = UploadIO
-    
+
     def self.io(object)
       if Hash === object and [:tempfile, :type, :filename].all? { |k| object.has_key? k } # Rack upload
         Transport::IO.new(object[:tempfile], object[:type], object[:filename])
-        
+
       elsif object.respond_to?(:content_type) and object.respond_to?(:original_filename) # Rails upload
         Transport::IO.new(object, object.content_type, object.original_filename)
-        
+
       else
         raise ArgumentError, "Could not generate a Transport::IO from #{object.inspect}"
       end
     end
-    
+
     def self.logger
       @logger ||= begin
                     require 'logger'
                     Logger.new(STDOUT)
                   end
     end
-    
+
     def self.logger=(logger)
       @logger = logger
     end
-    
+
     def self.verbose=(verbose)
       @verbose = verbose
     end
-    
+
     def self.verbose?
       @verbose
     end
-    
+
     def self.report
       Reporting.report
     end
-    
+
     def self.sanitize(*params)
       sanitized_params.concat(params)
     end
-    
+
     def self.sanitized_params
       @sanitized_params ||= []
     end
-    
+
   end
 end
-

data/spec/songkick/transport/authentication_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Songkick::Transport::Authentication do
+  def basic_auth_headers(*args)
+    Songkick::Transport::Authentication.basic_auth_headers(*args)
+  end
+
+  def strict_encode64(*args)
+    Songkick::Transport::Authentication.strict_encode64(*args)
+  end
+
+  describe "given basic auth credentials" do
+    let(:credentials) { {:username => "foo", :password => "baz"} } 
+    let(:headers) { basic_auth_headers(credentials) }
+    let(:encoded_credendials) { strict_encode64 "#{credentials[:username]}:#{credentials[:password]}"}
+
+    it "encodes the credentials correctly" do
+      expected_encoded_credentials = "Zm9vOmJheg=="
+      expect(encoded_credendials).to eq(expected_encoded_credentials)
+    end
+
+    it "gets correct headers" do
+      expected_auth_headers = Songkick::Transport::Headers.new({"Authorization" => "Basic Zm9vOmJheg=="})
+      expect(headers).to eq(expected_auth_headers)
+    end
+
+  end
+end

data/spec/songkick/transport/base_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe Songkick::Transport::Base do
+  let(:host) { 'base' }
+  subject { described_class.new(host) }
+
+
+  describe 'Instrumentation' do
+    subject { described_class.new(host, options) }
+
+    let(:options) do
+      { :instrumenter => ActiveSupport::Notifications }
+    end
+
+    context 'given a custom instrumentation label' do
+      before { options[:instrumentation_label] = 'a.custom.label' }
+
+      it 'instruments the request with the custom label' do
+        allow(subject).to receive(:execute_request)
+        expect(options[:instrumenter]).to receive(:instrument).with(options[:instrumentation_label], anything)
+        subject.get('/')
+      end
+    end
+  end
+
+  describe 'Basic auth' do
+    subject { described_class.new(host, options) }
+    let(:options) {{}}
+
+    context 'given basic auth credentials' do
+      before { options[:basic_auth] =  {:username => "foo", :password => "baz"} }
+
+      it 'should add basic auth credentials to subsequent requests' do
+        expect(subject).to receive(:execute_request) do |request|
+          expected_headers = {"Authorization"=>"Basic Zm9vOmJheg=="}
+          expect(request.headers).to include(expected_headers)
+          Songkick::Transport::Response::NoContent.new(204, {}, "")
+        end
+
+        subject.get('/')
+      end
+    end
+  end
+
+  describe "Decoration" do
+
+    it "should let you add headers" do
+      decorated_http = subject.with_headers("A" => "B")
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, Songkick::Transport::Headers.new("A" => "B"), nil)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add headers but then override them" do
+      decorated_http = subject.with_headers("A" => "B")
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, Songkick::Transport::Headers.new("A" => "A2", "C" => "D"), nil)
+
+      decorated_http.get("/", {}, {"A" => "A2", "C" => "D"})
+    end
+
+    it "should let you add headers multiple times and combine them" do
+      decorated_http = subject.with_headers("A" => "B").with_headers("C" => "D")
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, Songkick::Transport::Headers.new("A" => "B", "C" => "D"), nil)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add timeouts" do
+      decorated_http = subject.with_timeout(10)
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, {}, 10)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add a timeout but then override it" do
+      decorated_http = subject.with_timeout(10)
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, {}, 20)
+
+      decorated_http.get("/", {}, {}, 20)
+    end
+
+    it "should let you add timeouts multiple times and take the last" do
+      decorated_http = subject.with_timeout(10).with_timeout(20).with_timeout(30)
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, {}, 30)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add headers and timeouts" do
+      decorated_http = subject.with_headers("A" => "B").with_timeout(10)
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, Songkick::Transport::Headers.new("A" => "B"), 10)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add params" do
+      decorated_http = subject.with_params("admin" => "true")
+
+      expect(subject).to receive(:do_verb).with("get", "/", {"admin" => "true"}, {}, nil)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add params multiple times and merge them" do
+      decorated_http = subject.with_params("admin" => "true").with_params("foo" => "123")
+
+      expect(subject).to receive(:do_verb).with("get", "/", {"admin" => "true", "foo" => "123"}, {}, nil)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add basic authorization" do
+      decorated_http = subject.with_basic_auth({:username => "foo", :password => "bar"})
+      expected_auth_headers = {"Authorization" => "Basic Zm9vOmJhcg=="}
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, Songkick::Transport::Headers.new(expected_auth_headers), nil)
+
+      decorated_http.get("/")
+    end
+
+    it "should let you add basic authorization and merge them with other headers created by HeaderDecorator" do
+      decorated_http = subject.with_headers({"hello" => "world"}).with_basic_auth({:username => "foo", :password => "bar"})
+      expected_headers = {"Authorization" => "Basic Zm9vOmJhcg==", "hello" => "world"}
+
+      expect(subject).to receive(:do_verb).with("get", "/", {}, Songkick::Transport::Headers.new(expected_headers), nil)
+
+      decorated_http.get("/")
+    end
+
+    it "THE LOT" do
+      decorated_http = subject.with_basic_auth({:username => "foo", :password => "bar"}).with_headers("Version" => "3.0").with_params("foo" => "123").with_timeout(10)
+
+      expect(subject).to receive(:do_verb).with("get", "/", {"foo" => "123"}, Songkick::Transport::Headers.new("Version" => "3.0", "Authorization" => "Basic Zm9vOmJhcg=="), 10)
+
+      decorated_http.get("/")
+    end
+
+  end
+end

data/spec/songkick/transport/curb_spec.rb

@@ -2,59 +2,37 @@ 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(verb)
-          raise(@error, "bang") if @error
-        end
-        
-        def reset
-        end
-      end
-      
-      subject{ Curb.new('localhost', :connection => @fake_curl) }
-      let(:request){ Request.new('http://localhost', 'get', '/', {}) }
+      after { described_class.clear_thread_connection }
+
+      subject { described_class.new('localhost', :connection => 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
+          expect { subject.execute_request(request) }.to raise_error(exception)
         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
-          
+          let(:curl) { instance_double(Curl::Easy, :headers => {}).as_null_object }
+
+          before { allow(curl).to receive(:http).and_raise(raised_exception) }
+
           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)         }
+        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)         }
+        when_request_raises_the_exception(Curl::Err::RecvError)             { it_should_raise(Transport::UpstreamError)         }
       end
     end
-    
+
   end
 end

data/spec/songkick/transport/httparty_spec.rb

@@ -2,30 +2,30 @@ 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
+              expect(e.class).to eq(exception)
             end
           end
         end
@@ -36,7 +36,7 @@ module Songkick
               FakeHttparty.error = raised_exception
               @httparty = Songkick::Transport::HttParty.new('localhost', {:adapter => FakeHttparty})
             end
-          
+
             class_exec(&block)
           end
         end
@@ -50,6 +50,6 @@ module Songkick
         end
       end
     end
-    
+
   end
 end

data/spec/songkick/transport/request_spec.rb

@@ -25,37 +25,37 @@ describe Songkick::Transport::Request do
     context "with a get request" do
       it "returns the request as a curl command" do
         pattern = %r{^GET 'www.example.com/\?([^']+)' -H 'Authorization: Hello'$}
-        get_request.to_s.should =~ pattern
-        query(get_request, pattern).should == ["access[token]=foo", "password=CK", "username=Louis"]
+        expect(get_request.to_s).to match(pattern)
+        expect(query(get_request, pattern)).to eq(["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"]
+        expect(post_request.to_s).to match(pattern)
+        expect(query(post_request, pattern)).to eq(["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]", /Authorization/i]
+        allow(Songkick::Transport).to receive(:sanitized_params).and_return [/password/, "access[token]", /Authorization/i]
       end
 
       context "with a get request" do
         it "removes the parameter values from the request" do
           pattern = %r{^GET 'www.example.com/\?([^']+)' -H 'Authorization: \[REMOVED\]'$}
-          get_request.to_s.should =~ pattern
-          query(get_request, pattern).should == ["access[token]=[REMOVED]", "password=[REMOVED]", "username=Louis"]
+          expect(get_request.to_s).to match(pattern)
+          expect(query(get_request, pattern)).to eq(["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"]
+          expect(post_request.to_s).to match(pattern)
+          expect(query(post_request, pattern)).to eq(["access[token]=[REMOVED]", "password=[REMOVED]", "username=Louis"])
         end
       end
     end