kronk 1.0.0

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require "test/unit"
+require "kronk"
+require "mocha"
+
+
+def mock_200_response
+  @mock_200 ||= File.read 'test/mocks/200_response.txt'
+end
+
+
+def mock_301_response
+  @mock_301 ||= File.read 'test/mocks/301_response.txt'
+end
+
+
+def mock_302_response
+  @mock_302 ||= File.read 'test/mocks/302_response.txt'
+end
+
+
+def mock_data
+  {
+    "root" => [
+      ["B1", "B2"],
+      ["A1", "A2"],
+      ["C1", "C2", ["C3a", "C3b"]],
+      {:tests=>["D3a", "D3b"],
+      "test"=>[["D1a\nContent goes here", "D1b"], "D2"]}
+    ],
+    "acks"=>[[56, 78], ["12", "34"]],
+    "tests"=>{
+      :foo => :bar,
+      "test"=>[[1, 2], 2.123]
+    },
+    "subs"=>["a", "b"]
+  }
+end

data/test/test_kronk.rb

@@ -0,0 +1,192 @@
+require 'test/test_helper'
+
+class TestKronk < Test::Unit::TestCase
+
+  def test_default_config
+    expected = {
+      :content_types  => {
+        'js'      => 'JSON',
+        'json'    => 'JSON',
+        'plist'   => 'PlistParser',
+        'xml'     => 'XMLParser'
+      },
+      :cache_file  => Kronk::DEFAULT_CACHE_FILE,
+      :diff_format => :ascii_diff,
+      :requires    => []
+    }
+
+    assert_equal expected, Kronk::DEFAULT_CONFIG
+  end
+
+
+  def test_load_config
+    mock_config = {
+      :content_types => {
+        'soap' => "SOAPParser",
+        'js'   => "JsEngine"
+      },
+      :ignore_headers => ["Content-Type"],
+      :cache_file  => Kronk::DEFAULT_CACHE_FILE,
+      :requires    => [],
+      :foo => :bar
+    }
+
+    YAML.expects(:load_file).with(Kronk::DEFAULT_CONFIG_FILE).
+      returns mock_config
+
+    Kronk.load_config
+
+    expected = {
+      :content_types => {
+        'soap'  => "SOAPParser",
+        'js'    => "JsEngine",
+        'json'  => "JSON",
+        'plist' => "PlistParser",
+        'xml'   => "XMLParser"
+      },
+      :diff_format => :ascii_diff,
+      :cache_file  => Kronk::DEFAULT_CACHE_FILE,
+      :requires    => [],
+      :ignore_headers => ["Content-Type"],
+      :foo => :bar
+    }
+
+    assert_equal expected, Kronk.config
+  end
+
+
+  def test_make_config_file
+    file = mock 'file'
+    file.expects(:<<).with Kronk::DEFAULT_CONFIG.to_yaml
+    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')
+    assert_equal Kronk::PlistParser, Kronk.parser_for('plist')
+  end
+
+
+  def test_load_requires
+    old_requires = Kronk.config[:requires]
+    Kronk.config[:requires] = ["mock_lib1"]
+
+    assert_raises LoadError do
+      Kronk.load_requires
+    end
+
+    Kronk.config[:requires] = old_requires
+  end
+
+
+  def test_load_requires_nil
+    old_requires = Kronk.config[:requires]
+    Kronk.config[:requires] = nil
+
+    assert_nil Kronk.load_requires
+
+    Kronk.config[:requires] = old_requires
+  end
+
+
+  def test_find_const
+    assert_equal Nokogiri::XML::Document,
+                 Kronk.find_const("Nokogiri::XML::Document")
+
+    assert_equal JSON, Kronk.find_const("JSON")
+
+    assert_equal Kronk::XMLParser, Kronk.find_const("XMLParser")
+  end
+
+
+  def test_compare_raw
+    diff = Kronk.compare "test/mocks/200_response.json",
+                         "test/mocks/200_response.xml",
+                         :with_headers => true,
+                         :raw => true
+
+    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
+
+    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_compare_data
+    diff = Kronk.compare "test/mocks/200_response.json",
+                         "test/mocks/200_response.xml",
+                         :with_headers => true
+
+    resp1 = Kronk::Request.retrieve "test/mocks/200_response.json",
+                             :with_headers => true
+
+    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)
+
+    assert_equal exp_diff.formatted, diff.formatted
+  end
+
+  def test_raw_diff
+    diff = Kronk.raw_diff "test/mocks/200_response.json",
+                          "test/mocks/200_response.xml",
+                          :with_headers => true
+
+    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
+
+    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_data_diff
+    diff = Kronk.data_diff "test/mocks/200_response.json",
+                           "test/mocks/200_response.xml",
+                           :with_headers => true
+
+    resp1 = Kronk::Request.retrieve "test/mocks/200_response.json",
+                             :with_headers => true
+
+    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)
+
+    assert_equal exp_diff.formatted, diff.formatted
+  end
+
+
+  def test_parse_data_path_args
+    argv = %w{this is --argv -- one -two -- -three four}
+
+    assert_equal [%w{one four}, %w{two - three}],
+                 Kronk.parse_data_path_args(argv)
+
+    assert_equal %w{this is --argv}, argv
+  end
+end

data/test/test_request.rb

@@ -0,0 +1,225 @@
+require 'test/test_helper'
+
+class TestRequest < Test::Unit::TestCase
+
+  def test_follow_redirect
+    resp = mock "resp"
+    resp.expects(:[]).with("Location").returns "http://example.com"
+
+    options = {:follow_redirects => true}
+    Kronk::Request.expects(:retrieve_uri).with("http://example.com", options)
+
+    Kronk::Request.follow_redirect resp, options
+  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
+
+    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)
+  end
+
+
+  def test_dont_follow_redirect?
+    resp = mock "resp"
+    resp.expects(:code).returns "300"
+
+    assert !Kronk::Request.follow_redirect?(resp, false)
+
+    resp = mock "resp"
+    resp.expects(:code).returns "300"
+
+    assert !Kronk::Request.follow_redirect?(resp, 0)
+
+    resp = mock "resp"
+    resp.expects(:code).returns "200"
+
+    assert !Kronk::Request.follow_redirect?(resp, true)
+  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
+  end
+
+
+  def test_retrieve_cached
+    query   = "path/to/file.txt"
+    options = {:foo => "bar"}
+    Kronk::Request.expects(:retrieve_file).with query, options
+
+    Kronk::Request.retrieve query, options
+  end
+
+
+  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_cache
+    File.expects(:open).with(Kronk::DEFAULT_CACHE_FILE, "r").
+      yields StringIO.new(mock_200_response)
+
+    resp = Kronk::Request.retrieve_file :cache
+    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
+  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"
+  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
+
+    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
+      :follow_redirects => true
+  end
+
+
+  def test_retrieve_uri_redirect_3_times
+    resp = expect_request "POST", "http://example.com/request/path?foo=bar",
+              :status => '301', :data => "foo=bar"
+
+    Kronk::Request.expects(:follow_redirect).
+      with resp, :follow_redirects => 3, :data => {:foo => "bar"}
+
+    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
+      :follow_redirects => 3, :data => {:foo => "bar"}
+  end
+
+
+  def test_retrieve_uri_redirect_none
+    expect_request "GET", "http://example.com/request/path?foo=bar",
+      :status => 301
+
+    Kronk::Request.expects(:follow_redirect).never
+
+    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'}
+
+    Kronk::Request.retrieve_uri "http://example.com/request/path?foo=bar",
+      :http_method => :post,
+      :data => {:test => "thing"},
+      :headers => {'X-THING' => 'thing'}
+  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'}
+
+    assert_equal mock_200_response, resp.raw
+  end
+
+
+  def test_call_get
+    expect_request "GET", "http://example.com/request/path?foo=bar"
+    resp = Kronk::Request.call :get, "http://example.com/request/path?foo=bar"
+
+    assert_equal mock_200_response, resp.raw
+  end
+
+
+  def test_build_query_hash
+    hash = {
+      :foo => :bar,
+      :a => ['one', 'two'],
+      :b => {:b1 => [1,2], :b2 => "test"}
+    }
+
+    assert_equal "a[]=one&a[]=two&b[b1][]=1&b[b1][]=2&b[b2]=test&foo=bar",
+                  Kronk::Request.build_query(hash)
+  end
+
+
+  def test_build_query_non_hash
+    assert_raises ArgumentError do
+      Kronk::Request.build_query [1,2,3]
+    end
+
+    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
+
+
+  private
+
+  def expect_request req_method, url, options={}
+    uri  = URI.parse url
+
+    resp = mock 'resp'
+    resp.stubs(:code).returns(options[:status] || '200')
+
+    http = mock 'http'
+    socket = mock 'socket'
+
+    data   = options[:data]
+    data &&= Hash === data ? Kronk::Request.build_query(data) : data.to_s
+
+    socket.expects(:debug_output=)
+
+    http.expects(:send_request).
+      with(req_method, uri.request_uri, data, options[:headers]).
+      returns resp
+
+    http.expects(:instance_variable_get).with("@socket").returns socket
+
+    Net::HTTP.expects(:start).with(uri.host, uri.port).yields(http).returns resp
+
+    Kronk::Response.expects(:read_raw_from).returns ["", mock_200_response, 0]
+
+    resp
+  end
+end