kronk 1.4.0 → 1.5.0

data/test/test_helper_methods.rb

@@ -7,8 +7,8 @@ class TestHelperMethods < Test::Unit::TestCase
   def setup
     io          = StringIO.new mock_resp("200_response.json")
     @json       = JSON.parse mock_resp("200_response.json").split("\r\n\r\n")[1]
-    @mock_resp  = Kronk::Response.read_new io
-    @mock_resp2 = Kronk::Response.read_new \
+    @mock_resp  = Kronk::Response.new io
+    @mock_resp2 = Kronk::Response.new \
                     StringIO.new mock_resp("200_response.json")
 
     Kronk::Request.stubs(:retrieve).returns @mock_resp
@@ -134,7 +134,7 @@ class TestHelperMethods < Test::Unit::TestCase
 
 
   def test_retrieve_unparsable
-    mock_resp = Kronk::Response.read_new StringIO.new(mock_200_response)
+    mock_resp = Kronk::Response.new StringIO.new(mock_200_response)
 
     Kronk::Request.expects(:retrieve).
       with("host.com", :foo => "bar").returns mock_resp
@@ -152,7 +152,7 @@ class TestHelperMethods < Test::Unit::TestCase
 
 
   def test_retrieve_two_unparsable
-    mock_resp = Kronk::Response.read_new StringIO.new(mock_200_response)
+    mock_resp = Kronk::Response.new StringIO.new(mock_200_response)
 
     Kronk::Request.expects(:retrieve).
       with("host1.com", :foo => "bar").returns mock_resp

data/test/test_input_reader.rb

@@ -0,0 +1,103 @@
+require 'test/test_helper'
+
+class TestInputReader < Test::Unit::TestCase
+
+  def setup
+    @input = Kronk::Player::InputReader.new "/path1\n/path2\n/path3\n"
+  end
+
+
+  def test_init
+    input = Kronk::Player::InputReader.new "foobar"
+    assert_equal StringIO, input.io.class
+    assert_equal Kronk::Player::RequestParser, input.parser
+    assert_equal [], input.buffer
+
+
+    File.open("test/mocks/200_response.txt") do |file|
+      input = Kronk::Player::InputReader.new file, "mock parser"
+      assert_equal file, input.io
+      assert_equal "mock parser", input.parser
+    end
+  end
+
+
+  def test_get_next
+    (1..3).each do |num|
+      expected = {
+        :uri_suffix  => "/path#{num}"
+      }
+      assert_equal expected, @input.get_next
+    end
+
+    assert_nil @input.get_next
+    assert @input.eof?
+  end
+
+
+  def test_get_next_full_http_request
+    expected = {
+      :headers => {
+        "Accept"     => "*/*",
+        "User-Agent" => "Kronk/1.5.0 (http://github.com/yaksnrainbows/kronk)",
+        "Authorization" => "Basic Ym9iOmZvb2Jhcg=="
+      },
+      :http_method => "GET",
+      :uri_suffix  => "/path",
+      :host        => "example.com:80",
+    }
+
+    File.open("test/mocks/get_request.txt") do |file|
+      @input = Kronk::Player::InputReader.new file
+
+      assert_equal expected, @input.get_next
+      assert_nil @input.get_next
+      assert @input.eof?
+    end
+  end
+
+
+  def test_get_next_multiple_http_requests
+    expected = {
+      :headers => {
+        "Accept"     => "*/*",
+        "User-Agent" => "Kronk/1.5.0 (http://github.com/yaksnrainbows/kronk)",
+        "Authorization" => "Basic Ym9iOmZvb2Jhcg=="
+      },
+      :http_method => "GET",
+      :uri_suffix  => "/path",
+      :host        => "example.com:80",
+    }
+
+    req_str = File.read("test/mocks/get_request.txt") * 5
+
+    @input = Kronk::Player::InputReader.new req_str
+
+    5.times do
+      assert_equal expected, @input.get_next
+    end
+
+    assert_nil @input.get_next
+    assert @input.eof?
+  end
+
+
+  def test_eof
+    assert !@input.eof?
+
+    old_io, @input.io = @input.io, nil
+    assert @input.eof?
+
+    @input.io = old_io
+    @input.io.close
+    assert @input.eof?
+
+    @input.io.reopen
+    @input.io.read
+    assert @input.io.eof?
+    assert @input.eof?
+
+    @input.buffer << "test"
+    assert !@input.eof?
+  end
+end

data/test/test_kronk.rb

@@ -13,6 +13,7 @@ class TestKronk < Test::Unit::TestCase
       :cache_file   => Kronk::DEFAULT_CACHE_FILE,
       :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
       :history_file => Kronk::DEFAULT_HISTORY_FILE,
+      :indentation => 1,
       :default_host => "http://localhost:3000",
       :diff_format  => :ascii_diff,
       :show_lines   => false,
@@ -36,6 +37,7 @@ class TestKronk < Test::Unit::TestCase
       :cache_file  => Kronk::DEFAULT_CACHE_FILE,
       :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
       :history_file => Kronk::DEFAULT_HISTORY_FILE,
+      :indentation => 1,
       :show_lines  => false,
       :use_cookies => true,
       :requires    => [],
@@ -49,6 +51,11 @@ class TestKronk < Test::Unit::TestCase
 
     Kronk.load_config
 
+    YAML.expects(:load_file).with("foobar").
+      returns mock_config
+
+    Kronk.load_config "foobar"
+
     expected = {
       :content_types => {
         'soap'  => "SOAPParser",
@@ -62,6 +69,7 @@ class TestKronk < Test::Unit::TestCase
       :cache_file  => Kronk::DEFAULT_CACHE_FILE,
       :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
       :history_file => Kronk::DEFAULT_HISTORY_FILE,
+      :indentation => 1,
       :requires    => [],
       :show_lines  => false,
       :use_cookies => true,
@@ -76,17 +84,6 @@ class TestKronk < Test::Unit::TestCase
   end
 
 
-  def test_make_config_file
-    file = mock 'file'
-    file.expects(:<<).with Kronk::DEFAULT_CONFIG.to_yaml
-    File.expects(:directory?).with(Kronk::CONFIG_DIR).returns false
-    Dir.expects(:mkdir).with Kronk::CONFIG_DIR
-    File.expects(:open).with(Kronk::DEFAULT_CONFIG_FILE, "w+").yields file
-
-    Kronk.make_config_file
-  end
-
-
   def test_parser_for
     assert_equal JSON, Kronk.parser_for('json')
     assert_equal Kronk::XMLParser, Kronk.parser_for('xml')
@@ -94,25 +91,34 @@ class TestKronk < Test::Unit::TestCase
   end
 
 
-  def test_load_requires
-    old_requires = Kronk.config[:requires]
-    Kronk.config[:requires] = ["mock_lib1"]
+  def test_history
+    Kronk.instance_variable_set "@history", nil
+    File.expects(:file?).with(Kronk.config[:history_file]).returns true
+    File.expects(:read).with(Kronk.config[:history_file]).
+      returns "history1\nhistory2"
+
+    assert_equal %w{history1 history2}, Kronk.history
+  end
 
-    assert_raises LoadError do
-      Kronk.load_requires
-    end
 
-    Kronk.config[:requires] = old_requires
+  def test_history_no_file
+    Kronk.instance_variable_set "@history", nil
+    File.expects(:file?).with(Kronk.config[:history_file]).returns false
+    File.expects(:read).with(Kronk.config[:history_file]).never
+
+    assert_equal [], Kronk.history
   end
 
 
-  def test_load_requires_nil
-    old_requires = Kronk.config[:requires]
-    Kronk.config[:requires] = nil
+  def test_save_history
+    Kronk.instance_variable_set "@history", %w{hist1 hist2 hist1 hist3}
+    file = StringIO.new
+    File.expects(:open).with(Kronk.config[:history_file], "w").yields file
 
-    assert_nil Kronk.load_requires
+    Kronk.save_history
 
-    Kronk.config[:requires] = old_requires
+    file.rewind
+    assert_equal "hist1\nhist2\nhist3", file.read
   end
 
 
@@ -126,18 +132,18 @@ class TestKronk < Test::Unit::TestCase
   end
 
 
-  def test_merge_options_for_uri
+  def test_options_for_uri
     with_uri_options do
       assert_equal mock_uri_options['example'],
-        Kronk.merge_options_for_uri("http://example.com/path")
+        Kronk.new.options_for_uri("http://example.com/path")
 
       assert_equal Hash.new,
-        Kronk.merge_options_for_uri("http://thing.com/path")
+        Kronk.new.options_for_uri("http://thing.com/path")
     end
   end
 
 
-  def test_merge_options_for_uri_query
+  def test_options_for_uri_query
     data = {
       "add" => "this",
       "foo" => {
@@ -156,22 +162,22 @@ class TestKronk < Test::Unit::TestCase
       }
 
       %w{uri_query hash_query}.each do |qtype|
-        opts = Kronk.merge_options_for_uri("http://#{qtype}.com",
-                :query => data, :data => data)
+        opts = Kronk.new(:query => data, :data => data).
+                options_for_uri("http://#{qtype}.com")
 
         assert_equal expected, opts
       end
 
-      opts = Kronk.merge_options_for_uri("http://uri_query.com")
+      opts = Kronk.new.options_for_uri("http://uri_query.com")
       assert_equal mock_uri_options['uri_query'], opts
     end
   end
 
 
-  def test_merge_options_for_uri_headers
+  def test_options_for_uri_headers
     with_uri_options do
-      opts = Kronk.merge_options_for_uri("http://headers.example.com",
-              :headers => {'hdr2' => 2, 'hdr3' => 3})
+      opts = Kronk.new(:headers => {'hdr2' => 2, 'hdr3' => 3}).
+              options_for_uri("http://headers.example.com")
 
       expected = {
         :headers => {
@@ -187,10 +193,10 @@ class TestKronk < Test::Unit::TestCase
   end
 
 
-  def test_merge_options_for_uri_auth
+  def test_options_for_uri_auth
     with_uri_options do
-      opts = Kronk.merge_options_for_uri("http://auth.example.com",
-              :auth => {:username => "bob"})
+      opts = Kronk.new(:auth => {:username => "bob"}).
+              options_for_uri("http://auth.example.com")
 
       expected = {
         :auth => {
@@ -205,7 +211,7 @@ class TestKronk < Test::Unit::TestCase
   end
 
 
-  def test_merge_options_for_uri_proxy
+  def test_options_for_uri_proxy
     with_uri_options do
       expected = {
         :proxy => {
@@ -216,20 +222,20 @@ class TestKronk < Test::Unit::TestCase
         }
       }
 
-      opts = Kronk.merge_options_for_uri("http://proxy.com",
-              :proxy => "proxy.com")
+      opts = Kronk.new(:proxy => "proxy.com").
+              options_for_uri("http://proxy.com")
 
       assert_equal expected, opts
 
-      opts = Kronk.merge_options_for_uri("http://proxy.com",
-              :proxy => {:address => "proxy.com"})
+      opts = Kronk.new(:proxy => {:address => "proxy.com"}).
+              options_for_uri("http://proxy.com")
 
       assert_equal expected, opts
     end
   end
 
 
-  def test_merge_options_for_uri_str_proxy
+  def test_options_for_uri_str_proxy
     with_uri_options do
       expected = {
         :proxy => {
@@ -239,24 +245,24 @@ class TestKronk < Test::Unit::TestCase
         }
       }
 
-      opts = Kronk.merge_options_for_uri("http://strprox.com",
-              :proxy => {:username => "user", :password => "pass"})
+      opts = Kronk.new(:proxy => {:username => "user", :password => "pass"}).
+              options_for_uri("http://strprox.com")
 
       assert_equal expected, opts
 
-      opts = Kronk.merge_options_for_uri("http://strprox.com",
-              :proxy => "proxy.com")
+      opts = Kronk.new(:proxy => "proxy.com").
+              options_for_uri("http://strprox.com")
 
       assert_equal "proxy.com", opts[:proxy]
     end
   end
 
 
-  def test_merge_options_for_uri_with_headers
+  def test_options_for_uri_with_headers
     with_uri_options do
       %w{withhdrs withstrhdrs withtruehdrs}.each do |type|
-        opts = Kronk.merge_options_for_uri "http://#{type}.com",
-                :with_headers => true
+        opts = Kronk.new(:with_headers => true).
+                options_for_uri "http://#{type}.com"
 
         assert_equal true, opts[:with_headers]
       end
@@ -264,39 +270,34 @@ class TestKronk < Test::Unit::TestCase
   end
 
 
-  def test_merge_options_for_uri_with_headers_arr
+  def test_options_for_uri_with_headers_arr
     with_uri_options do
       %w{withhdrs withstrhdrs}.each do |type|
-        opts = Kronk.merge_options_for_uri "http://#{type}.com",
-                :with_headers => %w{hdr2 hdr3}
+        opts = Kronk.new(:with_headers => %w{hdr2 hdr3}).
+                options_for_uri "http://#{type}.com"
 
         assert_equal %w{hdr1 hdr2 hdr3}.sort, opts[:with_headers].sort
       end
 
-      opts = Kronk.merge_options_for_uri "http://withtruehdrs.com",
-              :with_headers => %w{hdr2 hdr3}
+      opts = Kronk.new(:with_headers => %w{hdr2 hdr3}).
+              options_for_uri "http://withtruehdrs.com"
 
       assert_equal %w{hdr2 hdr3}, opts[:with_headers]
     end
   end
 
 
-  def test_merge_options_for_uri_data_paths
+  def test_options_for_uri_data_paths
     expected = {
-      :only_data        => %w{path1 path2 path3},
-      :only_data_with   => %w{only1 only2},
-      :ignore_data      => "ign1",
-      :ignore_data_with => %w{ign2 ign3}
+      :only_data   => %w{path1 path2 path3},
+      :ignore_data => "ign1",
     }
 
     with_uri_options do
-      opts = Kronk.merge_options_for_uri "http://focus_data.com",
-              :only_data        => %w{path2 path3},
-              :only_data_with   => "only2",
-              :ignore_data_with => %w{ign2 ign3}
+      opts = Kronk.new(:only_data => %w{path2 path3}).
+              options_for_uri "http://focus_data.com"
 
       opts[:only_data].sort!
-      opts[:only_data_with].sort!
 
       assert_equal expected, opts
     end
@@ -309,11 +310,11 @@ class TestKronk < Test::Unit::TestCase
                          :with_headers => true,
                          :raw => true
 
-    resp1 = Kronk::Request.retrieve "test/mocks/200_response.json",
+    resp1 = Kronk.retrieve "test/mocks/200_response.json",
                              :with_headers => true,
                              :raw => true
 
-    resp2 = Kronk::Request.retrieve "test/mocks/200_response.xml",
+    resp2 = Kronk.retrieve "test/mocks/200_response.xml",
                              :with_headers => true,
                              :raw => true
 
@@ -361,6 +362,7 @@ class TestKronk < Test::Unit::TestCase
 
 
   def test_clear_cookies
+    Kronk.instance_variable_set "@cookie_jar", nil
     mock_cookie_jar = YAML.load_file("test/mocks/cookies.yml")
 
     File.expects(:file?).with(Kronk::DEFAULT_COOKIES_FILE).returns true
@@ -385,10 +387,10 @@ class TestKronk < Test::Unit::TestCase
                          "test/mocks/200_response.xml",
                          :with_headers => true
 
-    resp1 = Kronk::Request.retrieve "test/mocks/200_response.json",
+    resp1 = Kronk.retrieve "test/mocks/200_response.json",
                              :with_headers => true
 
-    resp2 = Kronk::Request.retrieve "test/mocks/200_response.xml",
+    resp2 = Kronk.retrieve "test/mocks/200_response.xml",
                              :with_headers => true
 
     exp_diff = Kronk::Diff.new_from_data \
@@ -399,103 +401,103 @@ class TestKronk < Test::Unit::TestCase
   end
 
 
-  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
+  def test_follow_redirect_infinite
+    res = Kronk::Response.new mock_301_response
+    req = Kronk::Request.new "http://www.google.com/"
+    req.stubs(:retrieve).returns res
+
+    Kronk::Request.stubs(:new).with("http://www.google.com/",{}).returns req
+    Kronk::Request.expects(:new).
+      with("http://www.google.com/", :follow_redirects => true).returns req
+
+    assert_raises Timeout::Error do
+      timeout(2) do
+        Kronk.retrieve "http://www.google.com/", :follow_redirects => true
+      end
+    end
   end
 
 
-  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
+  def test_num_follow_redirect
+    res = Kronk::Response.new mock_301_response
+    req = Kronk::Request.new "http://www.google.com/"
+    req.stubs(:retrieve).returns res
+
+    Kronk::Request.expects(:new).
+      with("http://www.google.com/",{}).returns(req).times(3)
+
+    Kronk::Request.expects(:new).
+      with("http://www.google.com/", :follow_redirects => 3).returns req
+
+    Kronk.retrieve "http://www.google.com/", :follow_redirects => 3
   end
 
 
-  def test_retrieve_data_string_struct
-    str = Kronk.retrieve_data_string "test/mocks/200_response.json",
-            :struct => true
+  def test_follow_redirect_no_redirect
+    res = Kronk::Response.new mock_200_response
+    req = Kronk::Request.new "http://www.google.com/"
+    req.stubs(:retrieve).returns res
+
+    Kronk::Request.expects(:new).with("http://www.google.com/",{}).never
+    Kronk::Request.expects(:new).
+      with("http://www.google.com/", :follow_redirects => true).returns req
+
+    Kronk.retrieve "http://www.google.com/", :follow_redirects => true
+  end
 
-    expected = JSON.parse \
-      File.read("test/mocks/200_response.json").split("\r\n\r\n")[1]
 
-    expected = Kronk::Diff.ordered_data_string expected, true
+  def test_do_not_follow_redirect
+    res = Kronk::Response.new mock_302_response
+    req = Kronk::Request.new "http://www.google.com/"
+    req.stubs(:retrieve).returns res
 
-    assert_equal expected, str
+    Kronk::Request.expects(:new).with("http://www.google.com/",{}).never
+    Kronk::Request.expects(:new).
+      with("http://www.google.com/", :follow_redirects => false).returns req
+
+    Kronk.retrieve "http://www.google.com/", :follow_redirects => false
   end
 
 
-  def test_retrieve_data_string_missing_parser
-    str = Kronk.retrieve_data_string "test/mocks/200_response.txt"
+  def test_compare_data_inst
+    kronk = Kronk.new :with_headers => true
+    diff  = kronk.compare "test/mocks/200_response.json",
+                          "test/mocks/200_response.xml"
+
+    json_resp = Kronk::Response.new(File.read("test/mocks/200_response.json"))
+    xml_resp  = Kronk::Response.new(File.read("test/mocks/200_response.xml"))
 
-    expected = File.read("test/mocks/200_response.txt").split("\r\n\r\n")[1]
+    assert_equal xml_resp.raw,  kronk.response.raw
+    assert_equal xml_resp.raw,  kronk.responses.last.raw
+    assert_equal json_resp.raw, kronk.responses.first.raw
+    assert_equal 2,             kronk.responses.length
+    assert_equal diff,          kronk.diff
 
-    assert_equal expected, str
+    resp1 = kronk.retrieve "test/mocks/200_response.xml"
+    resp2 = kronk.retrieve "test/mocks/200_response.json"
+
+    assert_equal json_resp.raw, kronk.response.raw
+    assert_equal json_resp.raw, kronk.responses.last.raw
+    assert_equal 1,             kronk.responses.length
+    assert_equal nil,           kronk.diff
+
+    exp_diff = Kronk::Diff.new_from_data \
+                  resp2.selective_data(:with_headers => true),
+                  resp1.selective_data(:with_headers => true)
+
+    assert_equal exp_diff.formatted, diff.formatted
   end
 
 
   def test_parse_data_path_args
     options = {}
-    argv = %w{this is --argv -- one -two -- -three four :parents :-not_parents}
-
-    Kronk::Cmd.expects(:warn).times(2)
+    argv = %w{this is --argv -- one -two -- -three four}
 
     options = Kronk::Cmd.parse_data_path_args options, argv
 
     assert_equal %w{one four}, options[:only_data]
     assert_equal %w{two - three}, options[:ignore_data]
 
-    assert_equal %w{parents}, options[:only_data_with]
-    assert_equal %w{not_parents}, options[:ignore_data_with]
-
     assert_equal %w{this is --argv}, argv
   end
 
@@ -558,7 +560,6 @@ STR
       },
       'focus_data'   => {
         :only_data      => %w{path1 path2},
-        :only_data_with => "only1",
         :ignore_data    => "ign1"
       }
     }