kronk 1.5.4 → 1.6.0

data/test/test_helper.rb

@@ -2,6 +2,8 @@ require "test/unit"
 require "kronk"
 require "mocha"
 
+Kronk.config[:context] = nil
+
 
 def mock_resp name
   File.read File.join("test/mocks", name)

data/test/test_kronk.rb

@@ -10,6 +10,7 @@ class TestKronk < Test::Unit::TestCase
         'plist'   => 'PlistParser',
         'xml'     => 'XMLParser'
       },
+      :context      => nil,
       :cache_file   => Kronk::DEFAULT_CACHE_FILE,
       :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
       :history_file => Kronk::DEFAULT_HISTORY_FILE,
@@ -34,6 +35,7 @@ class TestKronk < Test::Unit::TestCase
           'soap' => "SOAPParser",
           'js'   => "JsEngine"
         },
+        :context     => 3,
         :ignore_headers => ["Content-Type"],
         :cache_file  => Kronk::DEFAULT_CACHE_FILE,
         :cookies_file => Kronk::DEFAULT_COOKIES_FILE,
@@ -65,6 +67,7 @@ class TestKronk < Test::Unit::TestCase
           'plist' => "PlistParser",
           'xml'   => "XMLParser"
         },
+        :context     => 3,
         :default_host => "http://localhost:3000",
         :diff_format => :ascii_diff,
         :cache_file  => Kronk::DEFAULT_CACHE_FILE,
@@ -371,7 +374,11 @@ class TestKronk < Test::Unit::TestCase
                              :raw => true
 
     exp_diff = Kronk::Diff.new resp1.selective_string(:with_headers => true),
-                               resp2.selective_string(:with_headers => true)
+                               resp2.selective_string(:with_headers => true),
+                               :labels => [
+                                 "test/mocks/200_response.json",
+                                 "test/mocks/200_response.xml"
+                                ]
 
     assert_equal exp_diff.formatted, diff.formatted
   end
@@ -447,7 +454,11 @@ class TestKronk < Test::Unit::TestCase
 
     exp_diff = Kronk::Diff.new_from_data \
                   resp1.selective_data(:with_headers => true),
-                  resp2.selective_data(:with_headers => true)
+                  resp2.selective_data(:with_headers => true),
+                  :labels => [
+                    "test/mocks/200_response.json",
+                    "test/mocks/200_response.xml"
+                   ]
 
     assert_equal exp_diff.formatted, diff.formatted
   end
@@ -535,7 +546,12 @@ class TestKronk < Test::Unit::TestCase
 
     exp_diff = Kronk::Diff.new_from_data \
                   resp2.selective_data(:with_headers => true),
-                  resp1.selective_data(:with_headers => true)
+                  resp1.selective_data(:with_headers => true),
+                  :labels => [
+                    "test/mocks/200_response.json",
+                    "test/mocks/200_response.xml"
+                   ]
+
 
     assert_equal exp_diff.formatted, diff.formatted
   end

data/test/test_path.rb

@@ -26,113 +26,6 @@ class TestPath < Test::Unit::TestCase
   end
 
 
-  def test_each_data_item_hash
-    hash = {
-      :a => 1,
-      :b => 2,
-      :c => 3
-    }
-
-    keys = []
-    values = []
-
-    Kronk::Path.each_data_item hash do |key, val|
-      keys << key
-      values << val
-    end
-
-    assert_equal keys, (keys | hash.keys)
-    assert_equal values, (values | hash.values)
-  end
-
-
-  def test_each_data_item_array
-    ary = [:a, :b, :c]
-
-    keys = []
-    values = []
-
-    Kronk::Path.each_data_item ary do |key, val|
-      keys << key
-      values << val
-    end
-
-    assert_equal [2,1,0], keys
-    assert_equal ary.reverse, values
-  end
-
-
-  def test_match_data_item
-    assert Kronk::Path.match_data_item(:key, "key")
-    assert Kronk::Path.match_data_item("key", :key)
-
-    assert Kronk::Path.match_data_item(/key/, "foo_key")
-    assert !Kronk::Path.match_data_item("foo_key", /key/)
-    assert Kronk::Path.match_data_item(/key/, /key/)
-
-    assert Kronk::Path.match_data_item(Kronk::Path::ANY_VALUE, "foo_key")
-    assert !Kronk::Path.match_data_item("foo_key", Kronk::Path::ANY_VALUE)
-
-    assert Kronk::Path.match_data_item(1..3, 1)
-    assert !Kronk::Path.match_data_item(1, 1..3)
-    assert Kronk::Path.match_data_item(1..3, 1..3)
-  end
-
-
-  def test_find_match
-    keys = []
-
-    Kronk::Path.find_match @data, /key/ do |data, key|
-      keys << key.to_s
-      assert_equal @data, data
-    end
-
-    assert_equal ['key1', 'key2', 'key3'], keys.sort
-  end
-
-
-  def test_find_match_recursive
-    keys = []
-    data_points = []
-
-    Kronk::Path.find_match @data, :findme, ANY_VALUE, true do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert_equal 3, keys.length
-    assert_equal 1, keys.uniq.length
-    assert_equal "findme", keys.first
-
-    assert_equal 3, data_points.length
-    assert data_points.include?(@data)
-    assert data_points.include?({:findme => "thing"})
-    assert data_points.include?({:findme => 123456})
-  end
-
-
-  def test_find_match_value
-    keys = []
-    data_points = []
-
-    Kronk::Path.find_match @data, ANY_VALUE, "findme" do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert keys.empty?
-    assert data_points.empty?
-
-    Kronk::Path.find_match @data, ANY_VALUE, "findme", true do |data, key|
-      keys << key.to_s
-      data_points << data
-    end
-
-    assert_equal ['key1b'], keys
-    assert_equal [@data[:key1]], data_points
-  end
-
-
   def test_find_wildcard
     keys = []
     data_points = []
@@ -206,61 +99,86 @@ class TestPath < Test::Unit::TestCase
   end
 
 
-  def test_parse_path_item_range
-    assert_equal 1..4,   Kronk::Path.parse_path_item("1..4")
-    assert_equal 1...4,  Kronk::Path.parse_path_item("1...4")
-    assert_equal "1..4", Kronk::Path.parse_path_item("\\1..4")
-    assert_equal "1..4", Kronk::Path.parse_path_item("1\\..4")
-    assert_equal "1..4", Kronk::Path.parse_path_item("1.\\.4")
-    assert_equal "1..4", Kronk::Path.parse_path_item("1..\\4")
-    assert_equal "1..4", Kronk::Path.parse_path_item("1..4\\")
-  end
-
-
-  def test_parse_path_item_index_length
-    assert_equal 2...6, Kronk::Path.parse_path_item("2,4")
-    assert_equal "2,4", Kronk::Path.parse_path_item("\\2,4")
-    assert_equal "2,4", Kronk::Path.parse_path_item("2\\,4")
-    assert_equal "2,4", Kronk::Path.parse_path_item("2,\\4")
-    assert_equal "2,4", Kronk::Path.parse_path_item("2,4\\")
-  end
-
-
-  def test_parse_path_item_anyval
-    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item("*")
-    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item("")
-    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item("**?*?*?")
-    assert_equal Kronk::Path::ANY_VALUE, Kronk::Path.parse_path_item(nil)
+  def test_pathed
+    expected = {
+      "/findme/0"            => 123,
+      "/findme/1"            => 456,
+      "/findme/2/findme"     => 123456,
+      "/key1/key1a/0"        => "foo",
+      "/key1/key1a/1"        => "bar",
+      "/key1/key1a/2"        => "foobar",
+      "/key1/key1a/3/findme" => "thing",
+      "/key1/key1b"          => "findme",
+      "/key2"                => "foobar",
+      "/key3/key3a/0"        => "val1",
+      "/key3/key3a/1"        => "val2",
+      "/key3/key3a/2"        => "val3"
+    }
+    assert_equal expected, Kronk::Path.pathed(@data)
   end
 
 
-  def test_parse_path_item_regex
-    assert_equal(/\A(test.*)\Z/,     Kronk::Path.parse_path_item("test*"))
-    assert_equal(/\A(.?test.*)\Z/,   Kronk::Path.parse_path_item("?test*"))
-    assert_equal(/\A(\?test.*)\Z/,   Kronk::Path.parse_path_item("\\?test*"))
-    assert_equal(/\A(.?test\*.*)\Z/, Kronk::Path.parse_path_item("?test\\**"))
-    assert_equal(/\A(.?test.*)\Z/,   Kronk::Path.parse_path_item("?test*?**??"))
-    assert_equal(/\A(a|b)\Z/,        Kronk::Path.parse_path_item("a|b"))
-    assert_equal(/\A(a|b(c|d))\Z/,   Kronk::Path.parse_path_item("a|b(c|d)"))
-
-    assert_equal(/\A(a|b(c|d))\Z/i,
-      Kronk::Path.parse_path_item("a|b(c|d)", Regexp::IGNORECASE))
-  end
-
+  def test_pathed_esc
+    @data['findme'][2]['*thing?'] = {
+      ".." => "parent",
+      "**" => "recurse",
+      "(hi|hey)" => "paren",
+      "more/here" => "path"
+    }
 
-  def test_parse_path_item_string
-    assert_equal "a|b", Kronk::Path.parse_path_item("a\\|b")
-    assert_equal "a(b", Kronk::Path.parse_path_item("a\\(b")
-    assert_equal "a?b", Kronk::Path.parse_path_item("a\\?b")
-    assert_equal "a*b", Kronk::Path.parse_path_item("a\\*b")
+    expected = {
+      "/findme/0"            => 123,
+      "/findme/1"            => 456,
+      "/findme/2/findme"     => 123456,
+
+      "/findme/2/\\*thing\\?/\\.\\."         => "parent",
+      "/findme/2/\\*thing\\?/\\*\\*"         => "recurse",
+      "/findme/2/\\*thing\\?/\\(hi\\|hey\\)" => "paren",
+      "/findme/2/\\*thing\\?/more\\/here"    => "path",
+
+      "/key1/key1a/0"        => "foo",
+      "/key1/key1a/1"        => "bar",
+      "/key1/key1a/2"        => "foobar",
+      "/key1/key1a/3/findme" => "thing",
+      "/key1/key1b"          => "findme",
+      "/key2"                => "foobar",
+      "/key3/key3a/0"        => "val1",
+      "/key3/key3a/1"        => "val2",
+      "/key3/key3a/2"        => "val3"
+    }
+    assert_equal expected, Kronk::Path.pathed(@data)
   end
 
 
-  def test_parse_path_item_passthru
-    assert_equal Kronk::Path::PARENT,
-      Kronk::Path.parse_path_item(Kronk::Path::PARENT)
+  def test_pathed_not_esc
+    @data['findme'][2]['*thing?'] = {
+      ".." => "parent",
+      "**" => "recurse",
+      "(hi|hey)" => "paren",
+      "more/here" => "path"
+    }
 
-    assert_equal :thing, Kronk::Path.parse_path_item(:thing)
+    expected = {
+      "/findme/0"            => 123,
+      "/findme/1"            => 456,
+      "/findme/2/findme"     => 123456,
+
+      "/findme/2/*thing?/.."        => "parent",
+      "/findme/2/*thing?/**"        => "recurse",
+      "/findme/2/*thing?/(hi|hey)"  => "paren",
+      "/findme/2/*thing?/more/here" => "path",
+
+      "/key1/key1a/0"        => "foo",
+      "/key1/key1a/1"        => "bar",
+      "/key1/key1a/2"        => "foobar",
+      "/key1/key1a/3/findme" => "thing",
+      "/key1/key1b"          => "findme",
+      "/key2"                => "foobar",
+      "/key3/key3a/0"        => "val1",
+      "/key3/key3a/1"        => "val2",
+      "/key3/key3a/2"        => "val3"
+    }
+    assert_equal expected, Kronk::Path.pathed(@data, false)
   end
 
 
@@ -272,9 +190,10 @@ class TestPath < Test::Unit::TestCase
     end
 
     expected = [
-      ["path", ANY_VALUE, false, false],
-      ["to", "foo", true, false],
-      ["item", ANY_VALUE, false, true],
+      [Kronk::Path::Matcher.new(:key => "path"), false],
+      [Kronk::Path::Matcher.new(:key => "to", :value => "foo",
+        :recursive => true), false],
+      [Kronk::Path::Matcher.new(:key => "item"), true],
     ]
 
     assert_equal expected, all_args
@@ -289,22 +208,22 @@ class TestPath < Test::Unit::TestCase
 
     assert_path %w{path/to item/ i}, "path\\/to/item\\//i"
 
-    assert_path [/\A(path\/\.to)\Z/i, /\A(item)\Z/i],
+    assert_path [/\Apath\/\.to\Z/i, /\Aitem\Z/i],
        "path\\/.to/item", Regexp::IGNORECASE
 
-    assert_path ['path', /\A(to|for)\Z/, 'item'], "path/to|for/item"
+    assert_path ['path', /\Ato|for\Z/, 'item'], "path/to|for/item"
   end
 
 
   def test_parse_path_str_value
     assert_path ['path', ['to', 'foo'], 'item'], "path/to=foo/item"
-    assert_path ['path', [nil, 'foo'], 'item'],  "path/*=foo/item"
+    assert_path ['path', ["*", 'foo'], 'item'],  "path/*=foo/item"
     assert_path ['path', [nil, 'foo'], 'item'],  "path/=foo/item"
 
-    assert_path ['path', ['to', /\A(foo|bar)\Z/], 'item'],
+    assert_path ['path', ['to', /\Afoo|bar\Z/], 'item'],
       "path/to=foo|bar/item"
 
-    assert_path [/\A(path)\Z/i, [/\A(to)\Z/i, /\A(foo)\Z/i], /\A(item)\Z/i],
+    assert_path [/\Apath\Z/i, [/\Ato\Z/i, /\Afoo\Z/i], /\Aitem\Z/i],
       "path/to=foo/item", Regexp::IGNORECASE
   end
 
@@ -312,15 +231,15 @@ class TestPath < Test::Unit::TestCase
   def test_parse_path_str_recur
     assert_path ['path', ['to', 'foo', true], 'item'],    "path/**/to=foo/item"
     assert_path [['path', nil, true], 'to', 'item'],      "**/**/path/to/item"
-    assert_path ['path', 'to', 'item', [nil, nil, true]], "path/to/item/**/**"
-    assert_path ['path', [nil, 'foo', true], 'item'],     "path/**=foo/item"
+    assert_path ['path', 'to', 'item', ["*", nil, true]], "path/to/item/**/**"
+    assert_path ['path', ["*", 'foo', true], 'item'],     "path/**=foo/item"
   end
 
 
   def test_parse_path_str_parent
     assert_path ['path', PARENT, 'item'],              "path/../item"
     assert_path ['path', [PARENT, 'foo'], 'item'],     "path/..=foo/item"
-    assert_path ['path', [nil, 'foo', true], 'item'],  "path/**/..=foo/item"
+    assert_path ['path', ["*", 'foo', true], 'item'],  "path/**/..=foo/item"
     assert_path ['path', [nil, 'foo', true], 'item'],  "path/**/=foo/item"
     assert_path ['path', ['item', nil, true]],         "path/**/../item"
     assert_path ['path', PARENT, ['item', nil, true]], "path/../**/item"
@@ -354,15 +273,13 @@ class TestPath < Test::Unit::TestCase
   private
 
   PARENT    = Kronk::Path::PARENT
-  ANY_VALUE = Kronk::Path::ANY_VALUE
+  ANY_VALUE = Kronk::Path::Matcher::ANY_VALUE
 
   def assert_path match, path, regexp_opt=nil
     match.map! do |i|
       i = [i] unless Array === i
-      i[0] ||= ANY_VALUE
-      i[1] ||= ANY_VALUE
-      i[2] ||= false
-      i
+      Kronk::Path::Matcher.new :key => i[0], :value => i[1],
+        :recursive => i[2], :regex_opts => regexp_opt
     end
 
     assert_equal match, Kronk::Path.parse_path_str(path, regexp_opt)

data/test/test_path_match.rb

@@ -0,0 +1,60 @@
+require 'test/test_helper'
+
+class TestPathMatch < Test::Unit::TestCase
+
+  def setup
+    @pmatch = Kronk::Path::PathMatch.new %w{path to resource}
+    @pmatch.matches = %w{this is 4 foo}
+  end
+
+
+  def test_new
+    assert_equal %w{this is 4 foo},    @pmatch.matches
+    assert_equal %w{path to resource}, @pmatch
+  end
+
+
+  def test_dup
+    new_match = @pmatch.dup
+    assert_equal new_match, @pmatch
+    assert_not_equal @pmatch.matches.object_id, new_match.matches.object_id
+    assert_equal %w{this is 4 foo}, @pmatch.matches
+    assert_equal %w{this is 4 foo}, new_match.matches
+  end
+
+
+  def test_make_path
+    path = @pmatch.make_path "/%3/2/path/%4_%1"
+    assert_equal %w{4 2 path foo_this}, path
+  end
+
+
+  def test_make_path_bad_token
+    path = @pmatch.make_path "/%%3/2/path/%4_%1"
+    assert_equal %w{4 2 path foo_this}, path
+  end
+
+
+  def test_make_path_escape
+    path = @pmatch.make_path "/\\%3/2\\/path/%4_%1"
+    assert_equal %w{%3 2/path foo_this}, path
+
+    path = @pmatch.make_path "/\\\\%3/2/path/%4_%1/bar"
+    assert_equal %w{\4 2 path foo_this bar}, path
+  end
+
+
+  def test_make_path_escape_token_num
+    path = @pmatch.make_path "/%3\\1/2/path/%4_%1"
+    assert_equal %w{41 2 path foo_this}, path
+
+    path = @pmatch.make_path "/%\\31/2/path/%4_%1"
+    assert_equal %w{31 2 path foo_this}, path
+  end
+
+
+  def test_make_path_bad_token_num
+    path = @pmatch.make_path "/%31/2/path/%4_%1"
+    assert_equal ["", "2", "path", "foo_this"], path
+  end
+end