kronk 1.4.0 → 1.5.0

data/test/test_request.rb

@@ -2,173 +2,129 @@ require 'test/test_helper'
 
 class TestRequest < Test::Unit::TestCase
 
-  def test_follow_redirect
-    resp = mock "resp"
-    resp.expects(:[]).with("Location").returns "http://example.com"
+  def test_parse
+    raw = "POST /foobar\r\nAccept: json\r\nHost: example.com\r\n\r\nfoo=bar"
+    req = Kronk::Request.parse(raw)
 
-    options = {:follow_redirects => true, :http_method => :get}
-    Kronk::Request.expects(:retrieve_uri).with("http://example.com", options)
-
-    Kronk::Request.follow_redirect resp, options
+    assert_equal Kronk::Request, req.class
+    assert_equal URI.parse("http://example.com/foobar"), req.uri
+    assert_equal "json", req.headers['Accept']
+    assert_equal "foo=bar", req.body
   end
 
 
-  def test_num_follow_redirect
-    resp = mock "resp"
-    resp.expects(:[]).with("Location").returns "http://example.com"
-
-    options = {:follow_redirects => 1}
-    Kronk::Request.expects(:retrieve_uri).
-      with "http://example.com", :follow_redirects => 0, :http_method => :get
-
-    Kronk::Request.follow_redirect resp, options
-  end
-
-
-  def test_follow_redirect?
-    resp = mock "resp"
-    resp.expects(:code).returns "300"
-
-    assert Kronk::Request.follow_redirect?(resp, true)
-
-    resp = mock "resp"
-    resp.expects(:code).returns "300"
-
-    assert Kronk::Request.follow_redirect?(resp, 1)
+  def test_parse_invalid
+    assert_raises Kronk::Request::ParseError do
+      Kronk::Request.parse "thing\nfoo\n"
+    end
+    assert_raises Kronk::Request::ParseError do
+      Kronk::Request.parse ""
+    end
   end
 
 
-  def test_dont_follow_redirect?
-    resp = mock "resp"
-    resp.expects(:code).returns "300"
+  def test_parse_to_hash
+    expected = {:uri_suffix => "/foobar"}
+    assert_equal expected, Kronk::Request.parse_to_hash("/foobar")
 
-    assert !Kronk::Request.follow_redirect?(resp, false)
+    expected = {:http_method => "GET", :uri_suffix => "/foobar"}
+    assert_equal expected, Kronk::Request.parse_to_hash("GET /foobar")
 
-    resp = mock "resp"
-    resp.expects(:code).returns "300"
+    expected.merge! :host => "example.com"
+    raw = "GET /foobar\r\nHost: example.com"
+    assert_equal expected, Kronk::Request.parse_to_hash(raw)
 
-    assert !Kronk::Request.follow_redirect?(resp, 0)
+    expected.merge! :http_method => "POST",
+                    :data        => "foo=bar",
+                    :headers     => {'Accept' => 'json'}
 
-    resp = mock "resp"
-    resp.expects(:code).returns "200"
-
-    assert !Kronk::Request.follow_redirect?(resp, true)
+    raw = "POST /foobar\r\nAccept: json\r\nHost: example.com\r\n\r\nfoo=bar"
+    assert_equal expected, Kronk::Request.parse_to_hash(raw)
   end
 
 
-  def test_retrieve_live
-    query   = "http://example.com"
-    options = {:foo => "bar"}
-    Kronk::Request.expects(:retrieve_uri).with query, options
-
-    Kronk::Request.retrieve query, options
+  def test_parse_to_hash_invalid
+    assert_nil Kronk::Request.parse_to_hash("thing\nfoo\n")
+    assert_nil Kronk::Request.parse_to_hash("")
   end
 
 
-  def test_retrieve_cached
-    query   = "path/to/file.txt"
-    options = {:foo => "bar"}
-    File.expects(:file?).with(query).returns true
-    Kronk::Request.expects(:retrieve_file).with query, options
-
-    Kronk::Request.retrieve query, options
-  end
+  def test_retrieve_post
+    expect_request "POST", "http://example.com/request/path?foo=bar",
+      :data => {'test' => 'thing'}, :headers => {'X-THING' => 'thing'}
 
+    resp = Kronk::Request.new("http://example.com/request/path?foo=bar",
+            :data => 'test=thing', :headers => {'X-THING' => 'thing'},
+            :http_method => :post).retrieve
 
-  def test_retrieve_file
-    resp = Kronk::Request.retrieve_file "test/mocks/200_response.txt"
     assert_equal mock_200_response, resp.raw
-    assert_equal "200", resp.code
   end
 
 
-  def test_retrieve_file_redirect
-    resp2 = Kronk::Request.retrieve_file "test/mocks/200_response.txt"
-    Kronk::Request.expects(:follow_redirect).returns resp2
-
-    resp = Kronk::Request.retrieve_file "test/mocks/301_response.txt",
-            :follow_redirects => true
-
-    assert_equal mock_200_response, resp.raw
-    assert_equal "200", resp.code
+  def test_build_uri
+    uri = Kronk::Request.build_uri "https://example.com"
+    assert_equal URI.parse("https://example.com"), uri
   end
 
 
-  def test_retrieve_uri
-    expect_request "GET", "http://example.com/request/path?foo=bar"
-    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar"
+  def test_build_uri_string
+    uri = Kronk::Request.build_uri "example.com"
+    assert_equal "http://example.com", uri.to_s
   end
 
 
-  def test_retrieve_uri_redirect
-    resp = expect_request "GET", "http://example.com/request/path?foo=bar",
-            :status => '301'
-
-    Kronk::Request.expects(:follow_redirect).
-      with resp, :follow_redirects => true,
-      :headers => {'User-Agent' => Kronk::USER_AGENTS['kronk']},
-      :timeout => nil
-
-    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
-      :follow_redirects => true
+  def test_build_uri_localhost
+    uri = Kronk::Request.build_uri "/path/to/resource"
+    assert_equal "http://localhost:3000/path/to/resource", uri.to_s
   end
 
 
-  def test_retrieve_uri_redirect_3_times
-    resp = expect_request "POST", "http://example.com/request/path?foo=bar",
-              :status => '301', :data => "foo=bar"
+  def test_build_uri_query_hash
+    query = {'a' => '1', 'b' => '2'}
+    uri   = Kronk::Request.build_uri "example.com/path", :query => query
 
-    Kronk::Request.expects(:follow_redirect).
-      with resp, :follow_redirects => 3, :data => {:foo => "bar"},
-      :headers => {'User-Agent' => Kronk::USER_AGENTS['kronk']},
-      :timeout => nil
-
-    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
-      :follow_redirects => 3, :data => {:foo => "bar"}
+    assert_equal query, Kronk::Request.parse_nested_query(uri.query)
   end
 
 
-  def test_retrieve_uri_redirect_none
-    expect_request "GET", "http://example.com/request/path?foo=bar",
-      :status => 301
+  def test_build_uri_query_hash_str
+    query = {'a' => '1', 'b' => '2'}
+    uri   = Kronk::Request.build_uri "example.com/path?c=3", :query => query
 
-    Kronk::Request.expects(:follow_redirect).never
-
-    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar"
+    assert_equal({'a' => '1', 'b' => '2', 'c' => '3'},
+      Kronk::Request.parse_nested_query(uri.query))
   end
 
 
-  def test_retrieve_uri_post
-    expect_request "POST", "http://example.com/request/path?foo=bar",
-      :data => 'test=thing', :headers => {'X-THING' => 'thing'}
+  def test_build_uri_suffix
+    uri = Kronk::Request.build_uri "http://example.com/path",
+             :uri_suffix => "/to/resource"
 
-    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
-      :http_method => :post,
-      :data => {:test => "thing"},
-      :headers => {'X-THING' => 'thing'}
+    assert_equal "http://example.com/path/to/resource", uri.to_s
   end
 
 
-  def test_call_post
-    expect_request "POST", "http://example.com/request/path?foo=bar",
-      :data => {'test' => 'thing'}, :headers => {'X-THING' => 'thing'}
-
-    resp = Kronk::Request.call :post, "http://example.com/request/path?foo=bar",
-            :data => 'test=thing', :headers => {'X-THING' => 'thing'}
+  def test_build_uri_from_uri
+    query = {'a' => '1', 'b' => '2'}
+    uri   = Kronk::Request.build_uri URI.parse("http://example.com/path"),
+              :query => query, :uri_suffix => "/to/resource"
 
-    assert_equal mock_200_response, resp.raw
+    assert_equal "example.com",       uri.host
+    assert_equal "/path/to/resource", uri.path
+    assert_equal query, Kronk::Request.parse_nested_query(uri.query)
   end
 
 
-  def test_call_get
+  def test_retrieve_get
     expect_request "GET", "http://example.com/request/path?foo=bar"
-    resp = Kronk::Request.call :get, "http://example.com/request/path?foo=bar"
+    resp =
+      Kronk::Request.new("http://example.com/request/path?foo=bar").retrieve
 
     assert_equal mock_200_response, resp.raw
   end
 
 
-  def test_call_cookies
+  def test_retrieve_cookies
     Kronk.cookie_jar.expects(:get_cookie_header).
       with("http://example.com/request/path?foo=bar").returns "mock_cookie"
 
@@ -178,24 +134,24 @@ class TestRequest < Test::Unit::TestCase
     expect_request "GET", "http://example.com/request/path?foo=bar",
       :headers => {'Cookie' => "mock_cookie", 'User-Agent' => "kronk"}
 
-    resp = Kronk::Request.call :get, "http://example.com/request/path",
-            :query => "foo=bar", :headers => {'User-Agent' => "kronk"}
+    resp = Kronk::Request.new("http://example.com/request/path",
+            :query => "foo=bar", :headers => {'User-Agent' => "kronk"}).retrieve
   end
 
 
-  def test_call_no_cookies_found
+  def test_retrieve_no_cookies_found
     Kronk.cookie_jar.expects(:get_cookie_header).
       with("http://example.com/request/path?foo=bar").returns ""
 
     expect_request "GET", "http://example.com/request/path?foo=bar",
       :headers => {'User-Agent' => "kronk"}
 
-    resp = Kronk::Request.call :get, "http://example.com/request/path",
-            :query => "foo=bar", :headers => {'User-Agent' => "kronk"}
+    resp = Kronk::Request.new("http://example.com/request/path",
+            :query => "foo=bar", :headers => {'User-Agent' => "kronk"}).retrieve
   end
 
 
-  def test_call_no_cookies
+  def test_retrieve_no_cookies
     Kronk.cookie_jar.expects(:get_cookie_header).
       with("http://example.com/request/path?foo=bar").never
 
@@ -204,13 +160,13 @@ class TestRequest < Test::Unit::TestCase
     expect_request "GET", "http://example.com/request/path?foo=bar",
       :headers => {'User-Agent' => "kronk"}
 
-    resp = Kronk::Request.call :get, "http://example.com/request/path",
+    resp = Kronk::Request.new("http://example.com/request/path",
             :query => "foo=bar", :headers => {'User-Agent' => "kronk"},
-            :no_cookies => true
+            :no_cookies => true).retrieve
   end
 
 
-  def test_call_no_cookies_config
+  def test_retrieve_no_cookies_config
     old_config = Kronk.config[:use_cookies]
     Kronk.config[:use_cookies] = false
 
@@ -222,14 +178,14 @@ class TestRequest < Test::Unit::TestCase
     expect_request "GET", "http://example.com/request/path?foo=bar",
       :headers => {'User-Agent' => "kronk"}
 
-    resp = Kronk::Request.call :get, "http://example.com/request/path",
-            :query => "foo=bar", :headers => {'User-Agent' => "kronk"}
+    resp = Kronk::Request.new("http://example.com/request/path",
+            :query => "foo=bar", :headers => {'User-Agent' => "kronk"}).retrieve
 
     Kronk.config[:use_cookies] = old_config
   end
 
 
-  def test_call_no_cookies_config_override
+  def test_retrieve_no_cookies_config_override
     old_config = Kronk.config[:use_cookies]
     Kronk.config[:use_cookies] = false
 
@@ -241,61 +197,77 @@ class TestRequest < Test::Unit::TestCase
     expect_request "GET", "http://example.com/request/path?foo=bar",
       :headers => {'User-Agent' => "kronk"}
 
-    resp = Kronk::Request.call :get, "http://example.com/request/path",
+    resp = Kronk::Request.new("http://example.com/request/path",
             :query => "foo=bar", :headers => {'User-Agent' => "kronk"},
-            :no_cookies => false
+            :no_cookies => false).retrieve
 
     Kronk.config[:use_cookies] = old_config
   end
 
 
-  def test_call_cookies_already_set
+  def test_retrieve_cookies_already_set
     Kronk.cookie_jar.expects(:get_cookie_header).
       with("http://example.com/request/path?foo=bar").never
 
     expect_request "GET", "http://example.com/request/path?foo=bar",
-      :headers => {'User-Agent' => "kronk", 'Cookie' => "mock_cookie"}
+      :headers => {'User-Agent' => "kronk"}
 
-    resp = Kronk::Request.call :get, "http://example.com/request/path",
+    resp = Kronk::Request.new("http://example.com/request/path",
             :query => "foo=bar",
             :headers => {'User-Agent' => "kronk", 'Cookie' => "mock_cookie"},
-            :no_cookies => true
+            :no_cookies => true).retrieve
   end
 
 
-  def test_call_query
+  def test_retrieve_query
     expect_request "GET", "http://example.com/path?foo=bar"
-    Kronk::Request.call :get, "http://example.com/path",
-      :query => {:foo => :bar}
+    Kronk::Request.new("http://example.com/path",
+      :query => {:foo => :bar}).retrieve
   end
 
 
-  def test_call_query_appended
+  def test_retrieve_query_appended
     expect_request "GET", "http://example.com/path?foo=bar&test=thing"
-    Kronk::Request.call :get, "http://example.com/path?foo=bar",
-      :query => {:test => :thing}
+    Kronk::Request.new("http://example.com/path?foo=bar",
+      :query => {:test => :thing}).retrieve
   end
 
 
-  def test_call_query_appended_string
+  def test_retrieve_query_appended_string
     expect_request "GET", "http://example.com/path?foo=bar&test=thing"
-    Kronk::Request.call :get, "http://example.com/path?foo=bar",
-      :query => "test=thing"
+    Kronk::Request.new("http://example.com/path?foo=bar",
+      :query => "test=thing").retrieve
+  end
+
+
+  def test_auth_from_headers
+    req = Kronk::Request.parse File.read("test/mocks/get_request.txt")
+    assert_equal "bob",    req.auth[:username]
+    assert_equal "foobar", req.auth[:password]
   end
 
 
-  def test_call_basic_auth
+  def test_auth_from_headers_and_options
+    req = Kronk::Request.new "http://example.com/path",
+            :headers => {"Authorization" => "Basic Ym9iOmZvb2Jhcg=="},
+            :auth    => {:password => "password"}
+    assert_equal "bob",      req.auth[:username]
+    assert_equal "password", req.auth[:password]
+  end
+
+
+  def test_retrieve_basic_auth
     auth_opts = {:username => "user", :password => "pass"}
 
     expect_request "GET", "http://example.com" do |http, req, resp|
       req.expects(:basic_auth).with auth_opts[:username], auth_opts[:password]
     end
 
-    resp = Kronk::Request.call :get, "http://example.com", :auth => auth_opts
+    resp = Kronk::Request.new("http://example.com", :auth => auth_opts).retrieve
   end
 
 
-  def test_call_bad_basic_auth
+  def test_retrieve_bad_basic_auth
     auth_opts = {:password => "pass"}
 
     expect_request "GET", "http://example.com" do |http, req, resp|
@@ -303,81 +275,81 @@ class TestRequest < Test::Unit::TestCase
         never
     end
 
-    resp = Kronk::Request.call :get, "http://example.com", :auth => auth_opts
+    resp = Kronk::Request.new("http://example.com", :auth => auth_opts).retrieve
   end
 
 
-  def test_call_no_basic_auth
+  def test_retrieve_no_basic_auth
     expect_request "GET", "http://example.com" do |http, req, resp|
       req.expects(:basic_auth).never
     end
 
-    resp = Kronk::Request.call :get, "http://example.com"
+    resp = Kronk::Request.new("http://example.com").retrieve
   end
 
 
-  def test_call_ssl
+  def test_retrieve_ssl
     expr = expect_request "GET", "https://example.com" do |http, req, resp|
       req.expects(:use_ssl=).with true
     end
 
-    resp = Kronk::Request.call :get, "https://example.com"
+    resp = Kronk::Request.new("https://example.com").retrieve
 
     assert_equal mock_200_response, resp.raw
   end
 
 
-  def test_call_no_ssl
+  def test_retrieve_no_ssl
     expect_request "GET", "http://example.com" do |http, req, resp|
       req.expects(:use_ssl=).with(true).never
     end
 
-    resp = Kronk::Request.call :get, "http://example.com"
+    resp = Kronk::Request.new("http://example.com").retrieve
 
     assert_equal mock_200_response, resp.raw
   end
 
 
-  def test_call_user_agent_default
+  def test_retrieve_user_agent_default
     expect_request "GET", "http://example.com",
     :headers => {
       'User-Agent' =>
         "Kronk/#{Kronk::VERSION} (http://github.com/yaksnrainbows/kronk)"
     }
 
-    resp = Kronk::Request.call :get, "http://example.com"
+    resp = Kronk::Request.new("http://example.com").retrieve
   end
 
 
-  def test_call_user_agent_alias
+  def test_retrieve_user_agent_alias
     expect_request "GET", "http://example.com",
     :headers => {'User-Agent' => "Mozilla/5.0 (compatible; Konqueror/3; Linux)"}
 
-    resp = Kronk::Request.call :get, "http://example.com",
-             :user_agent => 'linux_konqueror'
+    resp = Kronk::Request.new("http://example.com",
+             :user_agent => 'linux_konqueror').retrieve
   end
 
 
-  def test_call_user_agent_custom
+  def test_retrieve_user_agent_custom
     expect_request "GET", "http://example.com",
     :headers => {'User-Agent' => "custom user agent"}
 
-    resp = Kronk::Request.call :get, "http://example.com",
-             :user_agent => 'custom user agent'
+    resp = Kronk::Request.new("http://example.com",
+             :user_agent => 'custom user agent').retrieve
   end
 
 
-  def test_call_user_agent_header_already_set
+  def test_retrieve_user_agent_header_already_set
     expect_request "GET", "http://example.com",
     :headers => {'User-Agent' => "custom user agent"}
 
-    resp = Kronk::Request.call :get, "http://example.com",
+    resp = Kronk::Request.new("http://example.com",
              :user_agent => 'mac_safari',
-             :headers    => {'User-Agent' => "custom user agent"}
+             :headers    => {'User-Agent' => "custom user agent"}).retrieve
   end
 
 
-  def test_call_proxy
+  def test_retrieve_proxy
     proxy = {
       :address  => "proxy.com",
       :username => "john",
@@ -389,11 +361,11 @@ class TestRequest < Test::Unit::TestCase
     Net::HTTP.expects(:Proxy).with("proxy.com", 8080, "john", "smith").
       returns Net::HTTP
 
-    Kronk::Request.call :get, "http://example.com", :proxy => proxy
+    Kronk::Request.new("http://example.com", :proxy => proxy).retrieve
   end
 
 
-  def test_call_proxy_string
+  def test_retrieve_proxy_string
     proxy = "proxy.com:8888"
 
     expect_request "GET", "http://example.com"
@@ -401,17 +373,17 @@ class TestRequest < Test::Unit::TestCase
     Net::HTTP.expects(:Proxy).with("proxy.com", "8888", nil, nil).
       returns Net::HTTP
 
-    Kronk::Request.call :get, "http://example.com", :proxy => proxy
+    Kronk::Request.new("http://example.com", :proxy => proxy).retrieve
   end
 
 
   def test_proxy_nil
-    assert_equal Net::HTTP, Kronk::Request.proxy(nil)
+    assert_equal Net::HTTP, Kronk::Request.new("host.com").use_proxy(nil)
   end
 
 
   def test_proxy_string
-    proxy_class = Kronk::Request.proxy("myproxy.com:80")
+    proxy_class = Kronk::Request.new("host.com").use_proxy("myproxy.com:80")
 
     assert_equal "myproxy.com",
       proxy_class.instance_variable_get("@proxy_address")
@@ -424,7 +396,7 @@ class TestRequest < Test::Unit::TestCase
 
 
   def test_proxy_no_port
-    proxy_class = Kronk::Request.proxy("myproxy.com")
+    proxy_class = Kronk::Request.new("host.com").use_proxy("myproxy.com")
 
     assert_equal "myproxy.com",
       proxy_class.instance_variable_get("@proxy_address")
@@ -437,10 +409,13 @@ class TestRequest < Test::Unit::TestCase
 
 
   def test_proxy_hash
-    proxy_class = Kronk::Request.proxy "myproxy.com",
-                                       :port      => 8080,
-                                       :username  => "john",
-                                       :password  => "smith"
+    req = Kronk::Request.new "http://example.com",
+            :proxy => { :address  => "myproxy.com",
+                        :port     => 8080,
+                        :username => "john",
+                        :password => "smith" }
+
+    proxy_class = req.instance_variable_get "@HTTP"
 
     assert_equal "myproxy.com",
       proxy_class.instance_variable_get("@proxy_address")
@@ -484,44 +459,4 @@ class TestRequest < Test::Unit::TestCase
     assert_equal "some/path", req.path
     assert_equal "vanilla kronk", req['User-Agent']
   end
-
-
-  private
-
-  def expect_request req_method, url, options={}
-    uri  = URI.parse url
-
-    resp_io = StringIO.new(mock_200_response)
-    resp = Kronk::Response.read_new resp_io #mock 'resp'
-    resp.stubs(:code).returns(options[:status] || '200')
-    resp.stubs(:to_hash).returns Hash.new
-
-    http   = mock 'http'
-    socket = mock 'socket'
-    req    = mock 'req'
-
-    data   = options[:data]
-    data &&= Hash === data ? Kronk::Request.build_query(data) : data.to_s
-
-    headers = options[:headers] || Hash.new
-    headers['User-Agent'] ||= Kronk.config[:user_agents]['kronk']
-
-    socket.expects(:debug_output=)
-
-    Kronk::Request::VanillaRequest.expects(:new).
-      with(req_method, uri.request_uri, headers).returns req
-
-    http.expects(:request).with(req, data).returns resp
-
-    http.expects(:instance_variable_get).with("@socket").returns socket
-
-    Net::HTTP.expects(:new).with(uri.host, uri.port).returns req
-    req.expects(:start).yields(http).returns resp
-
-    resp.expects(:read_raw_from).returns [nil, mock_200_response, nil]
-
-    yield http, req, resp if block_given?
-
-    resp
-  end
 end