RubyGems - kronk - Versions diffs - 1.0.3 → 1.1.0 - Mend

kronk 1.0.3 → 1.1.0

Files changed (18) hide show

data/{History.txt → History.rdoc} +22 -0
data/Manifest.txt +14 -2
data/README.rdoc +258 -0
data/Rakefile +4 -0
data/lib/kronk.rb +239 -102
data/lib/kronk/diff.rb +2 -2
data/lib/kronk/request.rb +146 -20
data/lib/kronk/xml_parser.rb +1 -1
data/test/mocks/200_response.json +28 -0
data/test/mocks/200_response.plist +97 -0
data/test/mocks/200_response.txt +23 -0
data/test/mocks/200_response.xml +58 -0
data/test/mocks/301_response.txt +16 -0
data/test/mocks/302_response.txt +17 -0
data/test/test_kronk.rb +142 -32
data/test/test_request.rb +319 -12
metadata +36 -20
data/README.txt +0 -122

data/test/mocks/301_response.txt ADDED Viewed

@@ -0,0 +1,16 @@
+HTTP/1.1 301 Moved Permanently
+Location: http://www.google.com/
+Content-Type: text/html; charset=UTF-8
+Date: Fri, 26 Nov 2010 16:14:45 GMT
+Expires: Sun, 26 Dec 2010 16:14:45 GMT
+Cache-Control: public, max-age=2592000
+Server: gws
+Content-Length: 219
+X-XSS-Protection: 1; mode=block
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+<TITLE>301 Moved</TITLE></HEAD><BODY>
+<H1>301 Moved</H1>
+The document has moved
+<A HREF="http://www.google.com/">here</A>.
+</BODY></HTML>

data/test/mocks/302_response.txt ADDED Viewed

@@ -0,0 +1,17 @@
+HTTP/1.1 302 Found
+Location: http://igoogle.com/
+Content-Type: text/html; charset=UTF-8
+Date: Fri, 26 Nov 2010 16:14:45 GMT
+Expires: Sun, 26 Dec 2010 16:14:45 GMT
+Cache-Control: public, max-age=2592000
+Server: gws
+Content-Length: 260
+X-XSS-Protection: 1; mode=block
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+<TITLE>302 Found</TITLE></HEAD><BODY>
+<H1>302 Found</H1>
+The document has moved
+<A HREF="http://www.google.com/">here</A>.
+<A HREF="http://igoogle.com/">here</A>.
+</BODY></HTML>

data/test/test_kronk.rb CHANGED Viewed

@@ -4,17 +4,20 @@ class TestKronk < Test::Unit::TestCase
   def test_default_config
     expected = {
-      :content_types  => {
+      :content_types => {
         'js'      => 'JSON',
         'json'    => 'JSON',
         'plist'   => 'PlistParser',
         'xml'     => 'XMLParser'
       },
-      :cache_file  => Kronk::DEFAULT_CACHE_FILE,
-      :diff_format => :ascii_diff,
-      :show_lines  => false,
-      :requires    => [],
-      :uri_options => {}
+      :cache_file   => Kronk::DEFAULT_CACHE_FILE,
+      :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
+      :diff_format  => :ascii_diff,
+      :show_lines   => false,
+      :use_cookies  => true,
+      :requires     => [],
+      :uri_options  => {},
+      :user_agents  => Kronk::USER_AGENTS
     }
     assert_equal expected, Kronk::DEFAULT_CONFIG
@@ -29,9 +32,12 @@ class TestKronk < Test::Unit::TestCase
       },
       :ignore_headers => ["Content-Type"],
       :cache_file  => Kronk::DEFAULT_CACHE_FILE,
+      :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
       :show_lines  => false,
+      :use_cookies => true,
       :requires    => [],
       :uri_options => {'example.com' => {:parser => 'JSON'}},
+      :user_agents => {:win_ie6 => 'piece of crap browser'},
       :foo => :bar
     }
@@ -50,10 +56,14 @@ class TestKronk < Test::Unit::TestCase
       },
       :diff_format => :ascii_diff,
       :cache_file  => Kronk::DEFAULT_CACHE_FILE,
+      :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
       :requires    => [],
       :show_lines  => false,
+      :use_cookies => true,
       :ignore_headers => ["Content-Type"],
       :uri_options => {'example.com' => {:parser => 'JSON'}},
+      :user_agents =>
+        Kronk::USER_AGENTS.merge(:win_ie6 => 'piece of crap browser'),
       :foo => :bar
     }
@@ -144,6 +154,62 @@ class TestKronk < Test::Unit::TestCase
   end
+  def test_load_cookie_jar
+    Kronk.clear_cookies!
+    mock_cookie_jar = YAML.load_file("test/mocks/cookies.yml")
+    File.expects(:file?).with(Kronk::DEFAULT_COOKIES_FILE).returns true
+    YAML.expects(:load_file).with(Kronk::DEFAULT_COOKIES_FILE).
+      returns mock_cookie_jar
+    cookie_jar = Kronk.load_cookie_jar
+    assert CookieJar::Jar === cookie_jar
+    assert !cookie_jar.get_cookies("http://rubygems.org/").empty?
+  end
+  def test_load_cookie_jar_no_file
+    Kronk.clear_cookies!
+    mock_cookie_jar = YAML.load_file("test/mocks/cookies.yml")
+    File.expects(:file?).with(Kronk::DEFAULT_COOKIES_FILE).returns false
+    YAML.expects(:load_file).with(Kronk::DEFAULT_COOKIES_FILE).never
+    cookie_jar = Kronk.load_cookie_jar
+    assert cookie_jar.get_cookies("http://rubygems.org/").empty?
+  end
+  def test_save_cookie_jar
+    mock_file = mock "mockfile"
+    mock_file.expects(:write).with Kronk.cookie_jar.to_yaml
+    File.expects(:open).with(Kronk::DEFAULT_COOKIES_FILE, "w").yields mock_file
+    Kronk.save_cookie_jar
+  end
+  def test_clear_cookies
+    mock_cookie_jar = YAML.load_file("test/mocks/cookies.yml")
+    File.expects(:file?).with(Kronk::DEFAULT_COOKIES_FILE).returns true
+    YAML.expects(:load_file).with(Kronk::DEFAULT_COOKIES_FILE).
+      returns mock_cookie_jar
+    assert !Kronk.cookie_jar.get_cookies("http://rubygems.org/").empty?
+    Kronk.clear_cookies!
+    assert Kronk.cookie_jar.get_cookies("http://rubygems.org/").empty?
+  end
+  def test_cookie_jar
+    assert_equal Kronk.instance_variable_get("@cookie_jar"), Kronk.cookie_jar
+  end
   def test_compare_data
     diff = Kronk.compare "test/mocks/200_response.json",
                          "test/mocks/200_response.xml",
@@ -163,42 +229,86 @@ class TestKronk < Test::Unit::TestCase
   end
-  def test_raw_diff
-    diff = Kronk.raw_diff "test/mocks/200_response.json",
-                          "test/mocks/200_response.xml",
-                          :with_headers => true
+  def test_retrieve_data_string
+    str = Kronk.retrieve_data_string "test/mocks/200_response.json"
+    expected = <<-STR
+{
+"business" => {
+ "address" => "3845 Rivertown Pkwy SW Ste 500",
+ "city" => "Grandville",
+ "description" => {
+  "additional_urls" => [
+   {
+    "destination" => "http://example.com",
+    "url_click" => "http://example.com"
+    }
+   ],
+  "general_info" => "<p>A Paint Your Own Pottery Studios..</p>",
+  "op_hours" => "Fri 1pm-7pm, Sat 10am-6pm, Sun 1pm-4pm, Appointments Available",
+  "payment_text" => "DISCOVER, AMEX, VISA, MASTERCARD",
+  "slogan" => "<p>Pottery YOU dress up</p>"
+  },
+ "distance" => 0.0,
+ "has_detail_page" => true,
+ "headings" => [
+  "Pottery"
+  ],
+ "id" => "1234",
+ "impression_id" => "mock_iid",
+ "improvable" => true,
+ "latitude" => 42.882561,
+ "listing_id" => "1234",
+ "listing_type" => "free",
+ "longitude" => -85.759586,
+ "mappable" => true,
+ "name" => "Naked Plates",
+ "omit_address" => false,
+ "omit_phone" => false,
+ "phone" => "6168055326",
+ "rateable" => true,
+ "rating_count" => 0,
+ "red_listing" => false,
+ "state" => "MI",
+ "website" => "http://example.com",
+ "year_established" => "1996",
+ "zip" => "49418"
+ },
+"original_request" => {
+ "id" => "1234"
+ },
+"request_id" => "mock_rid"
+}
+STR
+    assert_equal expected.strip, str
+  end
-    resp1 = Kronk::Request.retrieve "test/mocks/200_response.json",
-                             :with_headers => true,
-                             :raw => true
-    resp2 = Kronk::Request.retrieve "test/mocks/200_response.xml",
-                             :with_headers => true,
-                             :raw => true
+  def test_retrieve_data_string_raw
+    str = Kronk.retrieve_data_string "test/mocks/200_response.json", :raw => 1
+    expected = File.read("test/mocks/200_response.json").split("\r\n\r\n")[1]
+    assert_equal expected, str
+  end
-    exp_diff = Kronk::Diff.new resp1.selective_string(:with_headers => true),
-                               resp2.selective_string(:with_headers => true)
-    assert_equal exp_diff.formatted, diff.formatted
-  end
+  def test_retrieve_data_string_struct
+    str = Kronk.retrieve_data_string "test/mocks/200_response.json",
+            :struct => true
+    expected = JSON.parse \
+      File.read("test/mocks/200_response.json").split("\r\n\r\n")[1]
-  def test_data_diff
-    diff = Kronk.data_diff "test/mocks/200_response.json",
-                           "test/mocks/200_response.xml",
-                           :with_headers => true
+    expected = Kronk::Diff.ordered_data_string expected, true
-    resp1 = Kronk::Request.retrieve "test/mocks/200_response.json",
-                             :with_headers => true
+    assert_equal expected, str
+  end
-    resp2 = Kronk::Request.retrieve "test/mocks/200_response.xml",
-                             :with_headers => true
-    exp_diff = Kronk::Diff.new_from_data \
-                  resp1.selective_data(:with_headers => true),
-                  resp2.selective_data(:with_headers => true)
+  def test_retrieve_data_string_missing_parser
+    str = Kronk.retrieve_data_string "test/mocks/200_response.txt"
-    assert_equal exp_diff.formatted, diff.formatted
+    expected = File.read("test/mocks/200_response.txt").split("\r\n\r\n")[1]
+    assert_equal expected, str
   end

data/test/test_request.rb CHANGED Viewed

@@ -6,7 +6,7 @@ class TestRequest < Test::Unit::TestCase
     resp = mock "resp"
     resp.expects(:[]).with("Location").returns "http://example.com"
-    options = {:follow_redirects => true}
+    options = {:follow_redirects => true, :http_method => :get}
     Kronk::Request.expects(:retrieve_uri).with("http://example.com", options)
     Kronk::Request.follow_redirect resp, options
@@ -19,7 +19,7 @@ class TestRequest < Test::Unit::TestCase
     options = {:follow_redirects => 1}
     Kronk::Request.expects(:retrieve_uri).
-      with "http://example.com", :follow_redirects => 0
+      with "http://example.com", :follow_redirects => 0, :http_method => :get
     Kronk::Request.follow_redirect resp, options
   end
@@ -114,7 +114,8 @@ class TestRequest < Test::Unit::TestCase
             :status => '301'
     Kronk::Request.expects(:follow_redirect).
-      with resp, :follow_redirects => true
+      with resp, :follow_redirects => true,
+      :headers => {'User-Agent' => Kronk::USER_AGENTS['kronk']}
     Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
       :follow_redirects => true
@@ -126,7 +127,8 @@ class TestRequest < Test::Unit::TestCase
               :status => '301', :data => "foo=bar"
     Kronk::Request.expects(:follow_redirect).
-      with resp, :follow_redirects => 3, :data => {:foo => "bar"}
+      with resp, :follow_redirects => 3, :data => {:foo => "bar"},
+      :headers => {'User-Agent' => Kronk::USER_AGENTS['kronk']}
     Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
       :follow_redirects => 3, :data => {:foo => "bar"}
@@ -142,6 +144,7 @@ class TestRequest < Test::Unit::TestCase
     Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar"
   end
   def test_retrieve_uri_post
     expect_request "POST", "http://example.com/request/path?foo=bar",
       :data => 'test=thing', :headers => {'X-THING' => 'thing'}
@@ -172,6 +175,290 @@ class TestRequest < Test::Unit::TestCase
   end
+  def test_call_cookies
+    Kronk.cookie_jar.expects(:get_cookie_header).
+      with("http://example.com/request/path?foo=bar").returns "mock_cookie"
+    Kronk.cookie_jar.expects(:set_cookies_from_headers).
+      with("http://example.com/request/path?foo=bar", {})
+    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"}
+  end
+  def test_call_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"}
+  end
+  def test_call_no_cookies
+    Kronk.cookie_jar.expects(:get_cookie_header).
+      with("http://example.com/request/path?foo=bar").never
+    Kronk.cookie_jar.expects(:set_cookies_from_headers).never
+    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"},
+            :no_cookies => true
+  end
+  def test_call_no_cookies_config
+    old_config = Kronk.config[:use_cookies]
+    Kronk.config[:use_cookies] = false
+    Kronk.cookie_jar.expects(:get_cookie_header).
+      with("http://example.com/request/path?foo=bar").never
+    Kronk.cookie_jar.expects(:set_cookies_from_headers).never
+    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"}
+    Kronk.config[:use_cookies] = old_config
+  end
+  def test_call_no_cookies_config_override
+    old_config = Kronk.config[:use_cookies]
+    Kronk.config[:use_cookies] = false
+    Kronk.cookie_jar.expects(:get_cookie_header).
+      with("http://example.com/request/path?foo=bar").returns ""
+    Kronk.cookie_jar.expects(:set_cookies_from_headers)
+    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"},
+            :no_cookies => false
+    Kronk.config[:use_cookies] = old_config
+  end
+  def test_call_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"}
+    resp = Kronk::Request.call :get, "http://example.com/request/path",
+            :query => "foo=bar",
+            :headers => {'User-Agent' => "kronk", 'Cookie' => "mock_cookie"},
+            :no_cookies => true
+  end
+  def test_call_query
+    expect_request "GET", "http://example.com/path?foo=bar"
+    Kronk::Request.call :get, "http://example.com/path",
+      :query => {:foo => :bar}
+  end
+  def test_call_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}
+  end
+  def test_call_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"
+  end
+  def test_call_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
+  end
+  def test_call_bad_basic_auth
+    auth_opts = {:password => "pass"}
+    expect_request "GET", "http://example.com" do |http, req, resp|
+      req.expects(:basic_auth).with(auth_opts[:username], auth_opts[:password]).
+        never
+    end
+    resp = Kronk::Request.call :get, "http://example.com", :auth => auth_opts
+  end
+  def test_call_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"
+  end
+  def test_call_ssl
+    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"
+    assert_equal mock_200_response, resp.raw
+  end
+  def test_call_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"
+    assert_equal mock_200_response, resp.raw
+  end
+  def test_call_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"
+  end
+  def test_call_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'
+  end
+  def test_call_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'
+  end
+  def test_call_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",
+             :user_agent => 'mac_safari',
+             :headers    => {'User-Agent' => "custom user agent"}
+  end
+  def test_call_proxy
+    proxy = {
+      :address  => "proxy.com",
+      :username => "john",
+      :password => "smith"
+    }
+    expect_request "GET", "http://example.com"
+    Net::HTTP.expects(:Proxy).with("proxy.com", 8080, "john", "smith").
+      returns Net::HTTP
+    Kronk::Request.call :get, "http://example.com", :proxy => proxy
+  end
+  def test_call_proxy_string
+    proxy = "proxy.com:8888"
+    expect_request "GET", "http://example.com"
+    Net::HTTP.expects(:Proxy).with("proxy.com", "8888", nil, nil).
+      returns Net::HTTP
+    Kronk::Request.call :get, "http://example.com", :proxy => proxy
+  end
+  def test_proxy_nil
+    assert_equal Net::HTTP, Kronk::Request.proxy(nil)
+  end
+  def test_proxy_string
+    proxy_class = Kronk::Request.proxy("myproxy.com:80")
+    assert_equal "myproxy.com",
+      proxy_class.instance_variable_get("@proxy_address")
+    assert_equal '80', proxy_class.instance_variable_get("@proxy_port")
+    assert_nil proxy_class.instance_variable_get("@proxy_user")
+    assert_nil proxy_class.instance_variable_get("@proxy_pass")
+  end
+  def test_proxy_no_port
+    proxy_class = Kronk::Request.proxy("myproxy.com")
+    assert_equal "myproxy.com",
+      proxy_class.instance_variable_get("@proxy_address")
+    assert_equal 8080, proxy_class.instance_variable_get("@proxy_port")
+    assert_nil proxy_class.instance_variable_get("@proxy_user")
+    assert_nil proxy_class.instance_variable_get("@proxy_pass")
+  end
+  def test_proxy_hash
+    proxy_class = Kronk::Request.proxy "myproxy.com",
+                                       :port      => 8080,
+                                       :username  => "john",
+                                       :password  => "smith"
+    assert_equal "myproxy.com",
+      proxy_class.instance_variable_get("@proxy_address")
+    assert_equal 8080, proxy_class.instance_variable_get("@proxy_port")
+    assert_equal "john", proxy_class.instance_variable_get("@proxy_user")
+    assert_equal "smith", proxy_class.instance_variable_get("@proxy_pass")
+  end
   def test_build_query_hash
     hash = {
       :foo => :bar,
@@ -185,15 +472,27 @@ class TestRequest < Test::Unit::TestCase
   def test_build_query_non_hash
-    assert_raises ArgumentError do
-      Kronk::Request.build_query [1,2,3]
-    end
+    assert_equal [1,2,3].to_s, Kronk::Request.build_query([1,2,3])
     assert_equal "q[]=1&q[]=2&q[]=3", Kronk::Request.build_query([1,2,3], "q")
     assert_equal "key=val", Kronk::Request.build_query("val", "key")
   end
+  def test_vanilla_request
+    req = Kronk::Request::VanillaRequest.new :my_http_method,
+            "some/path", 'User-Agent' => 'vanilla kronk'
+    assert Net::HTTPRequest === req
+    assert_equal "MY_HTTP_METHOD", req.class::METHOD
+    assert req.class::REQUEST_HAS_BODY
+    assert req.class::RESPONSE_HAS_BODY
+    assert_equal "some/path", req.path
+    assert_equal "vanilla kronk", req['User-Agent']
+  end
   private
   def expect_request req_method, url, options={}
@@ -201,25 +500,33 @@ class TestRequest < Test::Unit::TestCase
     resp = mock 'resp'
     resp.stubs(:code).returns(options[:status] || '200')
+    resp.stubs(:to_hash).returns Hash.new
-    http = mock 'http'
+    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=)
-    http.expects(:send_request).
-      with(req_method, uri.request_uri, data, options[:headers]).
-      returns resp
+    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(:start).with(uri.host, uri.port).yields(http).returns resp
+    Net::HTTP.expects(:new).with(uri.host, uri.port).returns req
+    req.expects(:start).yields(http).returns resp
     Kronk::Response.expects(:read_raw_from).returns ["", mock_200_response, 0]
+    yield http, req, resp if block_given?
     resp
   end
 end