curb-fu 0.4.3

data/spec/lib/curb-fu/request/parameter_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+require 'curb-fu/core_ext'
+
+describe CurbFu::Request::Parameter do
+  describe "initialize" do
+    it "should accept a key and value pair" do
+      param = CurbFu::Request::Parameter.new("simple", "value")
+      param.name.should == "simple"
+      param.value.should == "value"
+    end
+    it "should accept a hash" do
+      lambda { CurbFu::Request::Parameter.new("policy",
+        { "archive_length_units" => "eons", "to" => "cthulhu@goo.org" }) }.should_not raise_error
+    end
+  end
+  
+  describe "to_uri_param" do
+    it "should serialize the key and value into an acceptable uri format" do
+      param = CurbFu::Request::Parameter.new("simple", "value")
+      param.to_uri_param.should == "simple=value"
+    end
+    describe "complex cases" do
+      it "should convert a hash parameter into the appropriate set of name-value pairs" do
+        params = CurbFu::Request::Parameter.new("policy", { "archive_length_units" => "eons", "to" => "cthulhu@goo.org" })
+        params.to_uri_param.should =~ /policy\[archive_length_units\]=eons/
+        params.to_uri_param.should =~ /policy\[to\]=cthulhu\%40goo\.org/
+        params.to_uri_param.should =~ /.+&.+/
+      end
+      it "should even handle cases where one of the hash parameters is an array" do
+        params = CurbFu::Request::Parameter.new("messages", { "failed" => [2134, 123, 4325], "policy_id" => 45 })
+        params.to_uri_param.should =~ /messages\[failed\]\[\]=2134/
+        params.to_uri_param.should =~ /messages\[failed\]\[\]=123/
+        params.to_uri_param.should =~ /messages\[failed\]\[\]=4325/
+        params.to_uri_param.should =~ /messages\[policy_id\]=45/
+        params.to_uri_param.should =~ /.+&.+&.+&.+/
+      end
+    end
+  end
+  
+  describe "to_curl_post_field" do
+    it "should serialize the key and value into an acceptable uri format" do
+      param = CurbFu::Request::Parameter.new("simple", "value")
+      field = param.to_curl_post_field
+      field.name.should == 'simple'
+      field.content.should == 'value'
+    end
+    describe "complex cases" do
+      it "should convert a hash parameter into the appropriate set of name-value pairs" do
+        params = CurbFu::Request::Parameter.new("policy",
+          { "archive_length_units" => "eons", "to" => "cthulhu@goo.org" })
+        fields = params.to_curl_post_field
+        fields.find { |f| f.name == 'policy[archive_length_units]' && f.content == 'eons'}.should_not be_nil
+        fields.find { |f| f.name == 'policy[to]' && f.content == 'cthulhu@goo.org'}.should_not be_nil
+      end
+      it "should even handle cases where one of the hash parameters is an array" do
+        params = CurbFu::Request::Parameter.new("messages", { "failed" => [2134, 123, 4325], "policy_id" => 45 }).
+          to_curl_post_field
+        params.find { |p| p.name == 'messages[failed][]' && p.content == '2134' }.should_not be_nil
+        params.find { |p| p.name == 'messages[failed][]' && p.content == '123' }.should_not be_nil
+        params.find { |p| p.name == 'messages[failed][]' && p.content == '4325' }.should_not be_nil
+        params.find { |p| p.name == 'messages[policy_id]' && p.content == '45' }.should_not be_nil
+      end
+      it "should not send a CGI-escaped value to Curl::PostField" do
+        field = CurbFu::Request::Parameter.new("messages", "uh-oh! We've failed!").
+          to_curl_post_field
+          
+        field.content.should == "uh-oh! We've failed!"
+      end
+      it "should not CGI-escape @ symbols" do
+        field = CurbFu::Request::Parameter.new("messages", "bob@apple.com").
+          to_curl_post_field
+          
+        field.content.should == "bob@apple.com"
+      end
+    end
+  end
+end

data/spec/lib/curb-fu/request/test_spec.rb

@@ -0,0 +1,223 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+def test_file_path
+  File.dirname(__FILE__) + "/../../../fixtures/foo.txt"
+end
+
+describe CurbFu::Request::Test do
+  before :each do
+    @a_server = mock(Object, :call => [200, { 'Content-Type' => 'spec/testcase' }, ["A is for Archer, an excellent typeface."]])
+    @b_server = mock(Object, :call => [200, {},["B is for Ballyhoo, like what happened when Twitter switched to Scala"]])
+    @c_server = mock(Object, :call => [200, {}, ["C is for Continuous, as in Integration"]])
+    
+    CurbFu.stubs = {
+      'a.example.com' => @a_server,
+      'b.example.com' => @b_server,
+      'c.example.com' => @c_server
+    }
+    
+    @mock_rack_response = mock(Rack::MockResponse, :status => 200, :headers => {}, :body => "C is for Continuous, as in Integration")
+  end
+  
+  describe "module inclusion" do
+    it "should define a 'get' method" do
+      class Test
+        include CurbFu::Request::Test
+      end
+      Test.should respond_to(:get)
+    end
+  end
+  
+  describe "parse_hostname" do
+    it "should return just the hostname from a full URL" do
+      CurbFu::Request.parse_hostname('http://a.example.com/foo/bar?transaxle=true').
+        should == 'a.example.com'
+    end
+    it 'should return the hostname if just a hostname is given' do
+      CurbFu::Request.parse_hostname('b.example.com').
+        should == 'b.example.com'
+    end
+  end
+  
+  describe "process_headers" do
+    it "should convert http headers into their upcased, HTTP_ prepended form for the Rack environment" do
+      CurbFu::Request.process_headers({'X-Mirror-Request' => 'true'}).should == {"HTTP_X_MIRROR_REQUEST" => "true"}
+    end
+    it "should handle a whole hashful of headers" do
+      CurbFu::Request.process_headers({
+        'X-Mirror-Request' => 'true',
+        'Accept-Encoding' => '*/*',
+        'X-Forwarded-For' => 'greenviewdata.com'
+      }).should == {
+        "HTTP_X_MIRROR_REQUEST" => "true",
+        "HTTP_ACCEPT_ENCODING" => "*/*",
+        "HTTP_X_FORWARDED_FOR" => "greenviewdata.com"
+      }
+    end
+  end
+  
+  describe "match_host" do
+    it "should return the appropriate Rack::Test instance to delegate the request to" do
+      CurbFu::Request.match_host("a.example.com").app.should == @a_server
+    end
+    it "should return nil if no match is made" do
+      CurbFu::Request.match_host("m.google.com").should be_nil
+    end
+  end
+  
+  describe "build_request_options" do
+    it "should parse headers" do
+      CurbFu::Request.build_request_options({:host => 'd.example.com', :path => '/big/white/dog', :headers => { 'Accept' => 'beer/pilsner' }}).
+        should include(:headers => { 'Accept' => 'beer/pilsner' })
+    end
+    it "should parse url" do
+      CurbFu::Request.build_request_options({:host => 'd.example.com', :path => '/big/white/dog'}).
+        should include(:url => 'http://d.example.com/big/white/dog')
+    end
+    it "should parse username and password" do
+      CurbFu::Request.build_request_options({:host => 'd.example.com', :path => '/big/white/dog', :username => 'bill', :password => 's3cr3t' }).
+        should include(:username => 'bill', :password => 's3cr3t')
+    end
+    it "should get an interface" do
+      CurbFu::Request.build_request_options({:host => 'c.example.com', :path => '/big/white/dog'}).
+        should include(:interface => CurbFu.stubs['c.example.com'])
+    end
+  end
+  
+  describe "get_interface" do
+    it "should parse a string" do
+      CurbFu::Request.get_interface('http://a.example.com').app.should == @a_server
+    end
+    it "should parse a hash" do
+      CurbFu::Request.get_interface({:host => 'a.example.com'}).app.should == @a_server
+    end
+  end
+  
+  describe "respond" do
+    it "should convert headers to uppercase, underscorized" do
+      CurbFu::Response::Base.stub!(:from_rack_response)
+      mock_interface = mock(Object, :send => mock(Object, :status => 200), :hostname= => nil, :hostname => 'a.example.com')
+      mock_interface.should_receive(:header).with('HTTP_X_MONARCHY','false')
+      mock_interface.should_receive(:header).with('HTTP_X_ANARCHO_SYNDICALIST_COMMUNE','true')
+      
+      CurbFu::Request.respond(mock_interface, :get, 'http://a.example.com/', {}, 
+        {'X-Anarcho-Syndicalist-Commune' => 'true', 'X-Monarchy' => 'false'}, nil, nil)
+    end
+  end
+  
+  describe "hashify_params" do
+    it "should turn a URL-formatted query string into a hash of parameters" do
+      hash = CurbFu::Request.hashify_params("color=red&shape=round")
+      hash.should include('color' => 'red')
+      hash.should include('shape' => 'round')
+    end
+    it "should convert array-formatted params into a hash of arrays" do
+      hash = CurbFu::Request.hashify_params("make[]=Chevrolet&make[]=Pontiac&make[]=GMC")
+      hash.should  == {'make' => ['Chevrolet','Pontiac','GMC']}
+    end
+    it "should convert hash parameters into a hash of hashes" do
+      hash = CurbFu::Request.hashify_params("car[make]=Chevrolet&car[color]=red&car[wheel_shape]=round")
+      hash.should  == {'car' => {
+        'make' => 'Chevrolet',
+        'color' => 'red',
+        'wheel_shape' => 'round'
+      }}
+    end
+    it 'should remove any leading ?s' do
+      hash = CurbFu::Request.hashify_params("?q=134&dave=astronaut")
+      hash.keys.should_not include('?q')
+    end
+  end
+  
+  describe "get" do
+    it 'should delegate the get request to the Rack::Test instance' do
+      CurbFu.stubs['a.example.com'].should_receive(:get).with('http://a.example.com/gimme/html', anything, anything).and_return(@mock_rack_response)
+      @a_server.should respond_to(:call)
+      CurbFu::Request.get('http://a.example.com/gimme/html')
+    end
+    it 'should raise Curl::Err::ConnectionFailedError if hostname is not defined in stub list' do
+      lambda { CurbFu::Request.get('http://m.google.com/gimme/html') }.should raise_error(Curl::Err::ConnectionFailedError)
+    end
+    it 'should return a CurbFu::Response object' do
+      response = CurbFu::Request.get('http://a.example.com/gimme/html')
+      response.should be_a_kind_of(CurbFu::Response::Base)
+      response.status.should == 200
+      response.headers.should == { 'Content-Type' => 'spec/testcase' }
+      response.body.should == "A is for Archer, an excellent typeface."
+    end
+  end
+  
+  describe "post" do
+    it 'should delegate the post request to the Rack::Test instance' do
+      CurbFu.stubs['b.example.com'].should_receive(:post).
+        with('http://b.example.com/html/backatcha', {'html' => 'CSRF in da house! <script type="text/compromise">alert("gotcha!")</script>'}, anything).
+        and_return(@mock_rack_response)
+      CurbFu::Request.post('http://b.example.com/html/backatcha',
+        {'html' => 'CSRF in da house! <script type="text/compromise">alert("gotcha!")</script>'})
+    end
+    it 'should raise Curl::Err::ConnectionFailedError if hostname is not defined in stub list' do
+      lambda { CurbFu::Request.post('http://m.google.com/gimme/html') }.should raise_error(Curl::Err::ConnectionFailedError)
+    end
+    it 'should return a CurbFu::Response object' do
+      response = CurbFu::Request.post('http://a.example.com/gimme/html')
+      response.should be_a_kind_of(CurbFu::Response::Base)
+      response.status.should == 200
+      response.headers.should == { 'Content-Type' => 'spec/testcase' }
+      response.body.should == "A is for Archer, an excellent typeface."
+    end
+  end
+  
+  describe "post_file" do
+    it 'should delegate the post request to the Rack::Test instance' do
+      CurbFu.stubs['b.example.com'].should_receive(:post).
+        with('http://b.example.com/html/backatcha', hash_including("foo.txt"=>anything, "filename"=>"asdf ftw"), anything).
+        and_return(@mock_rack_response)
+      CurbFu::Request.post_file('http://b.example.com/html/backatcha', {'filename' => 'asdf ftw'}, {'foo.txt' => test_file_path })
+    end
+    it 'should raise Curl::Err::ConnectionFailedError if hostname is not defined in stub list' do
+      lambda { CurbFu::Request.post_file('http://m.google.com/gimme/html') }.should raise_error(Curl::Err::ConnectionFailedError)
+    end
+    it 'should return a CurbFu::Response object' do
+      response = CurbFu::Request.post_file('http://a.example.com/gimme/html')
+      response.should be_a_kind_of(CurbFu::Response::Base)
+      response.status.should == 200
+      response.headers.should == { 'Content-Type' => 'spec/testcase' }
+      response.body.should == "A is for Archer, an excellent typeface."
+    end
+  end
+  
+  describe "put" do
+    it 'should delegate the put request to the Rack::Test instance' do
+      CurbFu.stubs['a.example.com'].should_receive(:put).with('http://a.example.com/gimme/html', anything, anything).and_return(@mock_rack_response)
+      CurbFu::Request.put('http://a.example.com/gimme/html')
+    end
+    it 'should raise Curl::Err::ConnectionFailedError if hostname is not defined in stub list' do
+      lambda { CurbFu::Request.put('http://m.google.com/gimme/html') }.should raise_error(Curl::Err::ConnectionFailedError)
+    end
+    it 'should return a CurbFu::Response object' do
+      response = CurbFu::Request.put('http://a.example.com/gimme/html')
+      response.should be_a_kind_of(CurbFu::Response::Base)
+      response.status.should == 200
+      response.headers.should == { 'Content-Type' => 'spec/testcase' }
+      response.body.should == "A is for Archer, an excellent typeface."
+    end
+  end
+  
+  describe "delete" do
+    it 'should delegate the delete request to the Rack::Test instance' do
+      CurbFu.stubs['a.example.com'].should_receive(:delete).with('http://a.example.com/gimme/html', anything, anything).and_return(@mock_rack_response)
+      @a_server.should respond_to(:call)
+      CurbFu::Request.delete('http://a.example.com/gimme/html')
+    end
+    it 'should raise Curl::Err::ConnectionFailedError if hostname is not defined in stub list' do
+      lambda { CurbFu::Request.delete('http://m.google.com/gimme/html') }.should raise_error(Curl::Err::ConnectionFailedError)
+    end
+    it 'should return a CurbFu::Response object' do
+      response = CurbFu::Request.delete('http://a.example.com/gimme/html')
+      response.should be_a_kind_of(CurbFu::Response::Base)
+      response.status.should == 200
+      response.headers.should == { 'Content-Type' => 'spec/testcase' }
+      response.body.should == "A is for Archer, an excellent typeface."
+    end
+  end
+end

data/spec/lib/curb-fu/response_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'htmlentities'
+
+describe CurbFu::Response::Base do
+  describe "from_rack_response" do
+    it "should create a new CurbFu::Response object out of a rack response (array)" do
+      rack = mock(Object, :status => 200, :headers => { 'Expires' => '05-12-2034' }, :body => "This will never go out of style")
+      response = CurbFu::Response::Base.from_rack_response(rack)
+      response.should be_a_kind_of(CurbFu::Response::OK)
+      response.body.should == "This will never go out of style"
+      response.headers.should include('Expires' => '05-12-2034')
+    end
+  end
+  
+  describe "from_curb_response" do
+    it "should create a new CurbFu::Response object out of a curb response object" do
+      curb = mock(Curl::Easy, :body_str => "Miscellaneous Facts About Curb", :header_str => "HTTP/1.1 200 OK\r\nCache-Control: private, max-age=0\r\nDate: Tue, 17 Mar 2009 17:34:08 GMT\r\nExpires: -1\r\n", :response_code => 200 )
+      response = CurbFu::Response::Base.from_curb_response(curb)
+      response.should be_a_kind_of(CurbFu::Response::OK)
+      response.body.should == "Miscellaneous Facts About Curb"
+      response.headers.should include("Expires" => '-1', "Cache-Control" => 'private, max-age=0')
+      response.status.should == 200
+    end
+  end
+  
+  describe "successes" do
+    it "should create a success (200) response" do
+      mock_curb = mock(Object, :response_code => 200, :body_str => 'OK', :header_str => "")
+      r = CurbFu::Response::Base.from_curb_response(mock_curb)
+      r.should be_a_kind_of(CurbFu::Response::Base)
+      r.should be_a_kind_of(CurbFu::Response::Success)
+      r.should be_a_kind_of(CurbFu::Response::OK)
+      r.should_not be_a_kind_of(CurbFu::Response::Created)
+    end
+    it "should create a success (201) response" do
+      mock_curb = mock(Object, :response_code => 201, :body_str => 'OK', :header_str => "")
+      r = CurbFu::Response::Base.from_curb_response(mock_curb)
+      r.should be_a_kind_of(CurbFu::Response::Base)
+      r.should be_a_kind_of(CurbFu::Response::Success)
+      r.should be_a_kind_of(CurbFu::Response::Created)
+    end
+  end
+  it "should create a 400 response" do
+    mock_curb = mock(Object, :response_code => 404, :body_str => 'OK', :header_str => "", :timeout= => nil)
+    r = CurbFu::Response::Base.from_curb_response(mock_curb)
+    r.should be_a_kind_of(CurbFu::Response::Base)
+    r.should be_a_kind_of(CurbFu::Response::ClientError)
+  end
+  it "should create a 500 response" do
+    mock_curb = mock(Object, :response_code => 503, :body_str => 'OK', :header_str => "", :timeout= => nil)
+    r = CurbFu::Response::Base.from_curb_response(mock_curb)
+    r.should be_a_kind_of(CurbFu::Response::Base)
+    r.should be_a_kind_of(CurbFu::Response::ServerError)
+  end
+  
+  describe "response modules" do
+    describe "to_i" do
+      it "should return the status code represented by the module" do
+        CurbFu::Response::OK.to_i.should == 200
+        CurbFu::Response::NotFound.to_i.should == 404
+      end
+    end
+  end
+  
+  describe "parse_headers" do
+    before(:each) do
+    end
+    
+    describe "test data" do
+      it "should parse all of Google's headers" do
+        headers = "HTTP/1.1 200 OK\r\nCache-Control: private, max-age=0\r\nDate: Tue, 17 Mar 2009 17:34:08 GMT\r\nExpires: -1\r\nContent-Type: text/html; charset=ISO-8859-1\r\nSet-Cookie: PREF=ID=16472704f58eb437:TM=1237311248:LM=1237311248:S=KrWlq33vvam8d_De; expires=Thu, 17-Mar-2011 17:34:08 GMT; path=/; domain=.google.com\r\nServer: gws\r\nTransfer-Encoding: chunked\r\n\r\n"
+        mock_curb = mock(Object, :response_code => 200, :body_str => 'OK', :header_str => headers, :timeout= => nil)
+        @cf = CurbFu::Response::Base.from_curb_response(mock_curb)
+        
+        @cf.headers['Cache-Control'].should == 'private, max-age=0'
+        @cf.headers['Date'].should == 'Tue, 17 Mar 2009 17:34:08 GMT'
+        @cf.headers['Expires'].should == '-1'
+        @cf.headers['Content-Type'].should == 'text/html; charset=ISO-8859-1'
+        @cf.headers['Set-Cookie'].should == 'PREF=ID=16472704f58eb437:TM=1237311248:LM=1237311248:S=KrWlq33vvam8d_De; expires=Thu, 17-Mar-2011 17:34:08 GMT; path=/; domain=.google.com'
+        @cf.headers['Server'].should == 'gws'
+        @cf.headers['Transfer-Encoding'].should == 'chunked'
+        @cf.headers.keys.length.should == 7
+      end
+      
+      it "should parse our json headers from the data_store" do
+        headers = "HTTP/1.1 200 OK\r\nServer: nginx/0.6.34\r\nDate: Tue, 17 Mar 2009 05:40:32 GMT\r\nContent-Type: text/json\r\nConnection: close\r\nContent-Length: 18\r\n\r\n"
+        mock_curb = mock(Object, :response_code => 200, :body_str => 'OK', :header_str => headers, :timeout= => nil)
+        @cf = CurbFu::Response::Base.from_curb_response(mock_curb)
+        
+        @cf.headers['Server'].should == 'nginx/0.6.34'
+        @cf.headers['Date'].should == 'Tue, 17 Mar 2009 05:40:32 GMT'
+        @cf.headers['Content-Type'].should == 'text/json'
+        @cf.headers['Connection'].should == 'close'
+        @cf.headers['Content-Length'].should == '18'
+        @cf.headers.keys.length.should == 5
+      end
+    end
+  end
+end

data/spec/lib/curb_fu_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe CurbFu do
+  describe "stubs=" do
+    it 'should insert the CurbFu::Request::Test module into CurbFu::Request' do
+      CurbFu.stubs = { 'example.com' => mock(Object, :call => [200, {}, "Hello, World"] ) }
+      CurbFu::Request.should include(CurbFu::Request::Test)
+    end
+    it 'should not insert the CurbFu::StubbedRequest module into CurbFu::Request if it is already there' do
+      CurbFu::Request.stub!(:include?).and_return(false, true)
+      CurbFu::Request.should_receive(:include).once
+      CurbFu.stubs = { 'example.com' => mock(Object, :call => [200, {}, "Hello, World"] ) }
+      CurbFu.stubs = { 'example.net' => mock(Object, :call => [404, {}, "not found"] ) }
+    end
+    it 'should not insert the CurbFu::StubbedRequest module if the method is given nil instead of a hash' do
+      CurbFu::Request.should_not_receive(:include)
+      CurbFu.stubs = nil
+    end
+  end
+
+  describe 'stub' do
+    it 'should create a stub interface for the given hostname using the supplied object' do
+      CurbFu.stubs = { 'localhost' => Object }
+      my_rack_app = mock(Object)
+      CurbFu.stub('webserver.com',my_rack_app)
+      CurbFu.stubs['webserver.com'].
+        should be_an_instance_of(CurbFu::Request::Test::Interface)
+      CurbFu.stubs = nil
+    end
+  end
+  
+  describe 'stubs' do
+    it 'should return nil by default' do
+      CurbFu.stubs = nil # no way to guarantee that CurbFu.stubs hasn't already been set by another spec
+      CurbFu.stubs.should be_nil
+    end
+    it 'should return a hash of hostnames pointing to CurbFu::StubbedRequest::TestInterfaces' do
+      CurbFu.stubs = { 'example.com' => mock(Object, :call => [200, {}, "Hello, World"] ) }
+      CurbFu.stubs['example.com'].should be_a_kind_of(CurbFu::Request::Test::Interface)
+    end
+    it 'should set the hostname on each interface' do
+      CurbFu.stubs = {
+        'ysthevanishedomens.com' => mock(Object)
+      }
+      
+      CurbFu.stubs['ysthevanishedomens.com'].hostname.should == 'ysthevanishedomens.com'
+    end
+  end
+end