kronk 1.0.0

data/test/test_data_set.rb

@@ -0,0 +1,410 @@
+require 'test/test_helper'
+
+class TestDataSet < Test::Unit::TestCase
+
+
+  def setup
+    @data = {
+      :key1 => {
+        :key1a => [
+          "foo",
+          "bar",
+          "foobar",
+          {:findme => "thing"}
+        ],
+        'key1b' => "findme"
+      },
+      'findme' => [
+        123,
+        456,
+        {:findme => 123456}
+      ],
+      :key2 => "foobar",
+      :key3 => {
+        :key3a => ["val1", "val2", "val3"]
+      }
+    }
+
+    @dataset = Kronk::DataSet.new @data
+
+    @dataset_mock = Kronk::DataSet.new mock_data
+  end
+
+
+  def test_collect_data_points_single
+    data = @dataset_mock.collect_data_points "subs/1"
+    assert_equal({"subs" => [nil, "b"]}, data)
+  end
+
+
+  def test_collect_data_points_single_wildcard
+    data = @dataset_mock.collect_data_points "root/*/tests"
+    assert_equal({"root"=>[nil, nil, nil, {:tests=>["D3a", "D3b"]}]}, data)
+  end
+
+
+  def test_collect_data_points_recursive_wildcard
+    data = @dataset_mock.collect_data_points "**/test?"
+
+    expected = {
+      "tests"=>{:foo=>:bar, "test"=>[[1, 2], 2.123]},
+      "root"=>[nil, nil, nil, {
+        :tests=>["D3a", "D3b"],
+        "test"=>[["D1a\nContent goes here", "D1b"], "D2"]}]
+    }
+
+    assert_equal expected, data
+  end
+
+
+  def test_collect_data_points_recursive_wildcard_value
+    data = @dataset_mock.collect_data_points "**=(A|a)?"
+
+    expected = {
+      "root" => [nil, ["A1", "A2"]],
+      "subs" => ["a"]
+    }
+
+    assert_equal expected, data
+  end
+
+
+  def test_delete_data_points_single
+    data = @dataset_mock.delete_data_points "subs/1"
+
+    expected = mock_data
+    expected['subs'].delete_at 1
+
+    assert_equal expected, data
+  end
+
+
+  def test_delete_data_points_single_wildcard
+    data = @dataset_mock.delete_data_points "root/*/tests"
+
+    expected = mock_data
+    expected['root'][3].delete :tests
+
+    assert_equal expected, data
+  end
+
+
+  def test_delete_data_points_single_wildcard_qmark
+    data = @dataset_mock.delete_data_points "subs/?"
+
+    expected = mock_data
+    expected['subs'].clear
+
+    assert_equal expected, data
+  end
+
+
+  def test_delete_data_points_recursive_wildcard
+    data = @dataset_mock.delete_data_points "**/test?"
+
+    expected = mock_data
+    expected['root'][3].delete :tests
+    expected['root'][3].delete 'test'
+    expected.delete "tests"
+
+    assert_equal expected, data
+  end
+
+
+  def test_delete_data_points_recursive_wildcard_value
+    data = @dataset_mock.delete_data_points "**=A?|a?"
+
+    expected = mock_data
+    expected['root'][1].clear
+    expected['subs'] = ["b"]
+
+    assert_equal expected, data
+  end
+
+
+  def test_find_data_index
+    keys = []
+    data_points = []
+
+    @dataset.find_data "*/*/0|1" do |data, key, path|
+      keys << key
+      data_points << data
+    end
+
+    assert_equal [0,1,0,1], keys
+    assert_equal 2, data_points.count(@data[:key1][:key1a])
+    assert_equal 2, data_points.count(@data[:key3][:key3a])
+  end
+
+
+  def test_find_data_recursive_wildcard_value
+    keys = []
+    paths = []
+    data_points = []
+
+    @dataset.find_data "**=foo*" do |data, key, path|
+      keys << key
+      data_points << data
+      paths << path
+    end
+
+    expected_paths = [[:key1,:key1a,0], [:key1,:key1a,2], [:key2]]
+
+    assert_equal [0,2,:key2], ([0,2,:key2] | keys)
+    assert_equal expected_paths, (expected_paths | paths)
+  end
+
+
+  def test_find_data_recursive
+    keys = []
+    paths = []
+    data_points = []
+
+    @dataset.find_data "**/findme" do |data, key, path|
+      keys << key.to_s
+      data_points << data
+      paths << path
+    end
+
+    expected_paths =
+      [[:key1,:key1a,3,:findme], ["findme"], ["findme",2,:findme]]
+
+    assert_equal 3, keys.length
+    assert_equal 1, keys.uniq.length
+    assert_equal "findme", keys.first
+
+    assert data_points.include?(@data)
+    assert data_points.include?(@data[:key1][:key1a].last)
+    assert data_points.include?(@data['findme'].last)
+
+    assert_equal expected_paths, (expected_paths | paths)
+  end
+
+
+  def test_find_data_wildcard
+    keys = []
+    data_points = []
+
+    @dataset.find_data "*/key1?" do |data, key, path|
+      keys << key.to_s
+      data_points << data
+    end
+
+    assert_equal ['key1a', 'key1b'], keys.sort
+    assert_equal [@data[:key1], @data[:key1]], data_points
+  end
+
+
+  def test_parse_data_path
+    data_path = "key1/key\\/2=value/key*=*value/**=value2/key\\=thing"
+    key, value, rec, data_path = Kronk::DataSet.parse_data_path data_path
+
+    assert_equal "key1", key
+    assert_nil value
+    assert !rec, "Should not return recursive = true"
+    assert_equal "key\\/2=value/key*=*value/**=value2/key\\=thing", data_path
+  end
+
+
+  def test_parse_data_path_escaped_slash
+    key, value, rec, data_path =
+      Kronk::DataSet.parse_data_path \
+        "key\\/2=value/key*=*value/**=value2/key\\=thing"
+
+    assert_equal "key/2", key
+    assert_equal "value", value
+    assert !rec, "Should not return recursive = true"
+    assert_equal "key*=*value/**=value2/key\\=thing", data_path
+  end
+
+
+  def test_parse_data_path_wildcard
+    key, value, rec, data_path = Kronk::DataSet.parse_data_path "*/key1?"
+
+    assert_equal(/^(.*)$/, key)
+    assert_nil value
+    assert !rec, "Should not return recursive = true"
+    assert_equal "key1?", data_path
+  end
+
+
+  def test_parse_data_path_recursive_value
+    key, value, rec, data_path =
+      Kronk::DataSet.parse_data_path "**=value2/key\\=thing"
+
+    assert_equal(/.*/, key)
+    assert_equal "value2", value
+    assert rec, "Should return recursive = true"
+    assert_equal "key\\=thing", data_path
+  end
+
+
+  def test_parse_data_path_recursive
+    data_path = "**"
+    key, value, rec, data_path = Kronk::DataSet.parse_data_path "**"
+
+    assert_equal(/.*/, key)
+    assert_nil value
+    assert rec, "Should return recursive = true"
+    assert_nil data_path
+  end
+
+
+  def test_parse_data_path_recursive_key
+    data_path = "**"
+    key, value, rec, data_path = Kronk::DataSet.parse_data_path "**/key"
+
+    assert_equal "key", key
+    assert_nil value
+    assert rec, "Should return recursive = true"
+    assert_nil data_path
+  end
+
+
+  def test_parse_data_path_escaped_equal
+    key, value, rec, data_path = Kronk::DataSet.parse_data_path "key\\=thing"
+
+    assert_equal "key=thing", key
+    assert_nil value
+    assert !rec, "Should not return recursive = true"
+    assert_equal nil, data_path
+  end
+
+
+  def test_parse_data_path_last
+    key, value, rec, data_path = Kronk::DataSet.parse_data_path "key*"
+
+    assert_equal(/^(key.*)$/, key)
+    assert_nil value
+    assert !rec, "Should not return recursive = true"
+    assert_equal nil, data_path
+  end
+
+
+  def test_parse_data_path_empty
+    key, value, rec, data_path = Kronk::DataSet.parse_data_path ""
+
+    assert_equal nil, key
+    assert_nil value
+    assert !rec, "Should not return recursive = true"
+    assert_equal nil, data_path
+  end
+
+
+  def test_parse_path_item
+    assert_equal "foo", Kronk::DataSet.parse_path_item("foo")
+
+    assert_equal(/^(foo.*bar)$/, Kronk::DataSet.parse_path_item("foo*bar"))
+    assert_equal(/^(foo|bar)$/, Kronk::DataSet.parse_path_item("foo|bar"))
+    assert_equal(/^(foo.?bar)$/, Kronk::DataSet.parse_path_item("foo?bar"))
+
+    assert_equal(/^(foo.?\?bar)$/, Kronk::DataSet.parse_path_item("foo?\\?bar"))
+    assert_equal(/^(key.*)$/, Kronk::DataSet.parse_path_item("key*"))
+
+    assert_equal "foo*bar", Kronk::DataSet.parse_path_item("foo\\*bar")
+    assert_equal "foo|bar", Kronk::DataSet.parse_path_item("foo\\|bar")
+    assert_equal "foo?bar", Kronk::DataSet.parse_path_item("foo\\?bar")
+  end
+
+
+  def test_yield_data_points
+    keys = []
+
+    Kronk::DataSet.yield_data_points @data, /key/ do |data, key|
+      keys << key.to_s
+      assert_equal @data, data
+    end
+
+    assert_equal ['key1', 'key2', 'key3'], keys.sort
+  end
+
+
+  def test_yield_data_points_recursive
+    keys = []
+    data_points = []
+
+    Kronk::DataSet.yield_data_points @data, :findme, nil, 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_yield_data_points_value
+    keys = []
+    data_points = []
+
+    Kronk::DataSet.yield_data_points @data, nil, "findme" do |data, key|
+      keys << key.to_s
+      data_points << data
+    end
+
+    assert keys.empty?
+    assert data_points.empty?
+
+    Kronk::DataSet.yield_data_points @data, nil, "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_match_data_item
+    assert Kronk::DataSet.match_data_item(:key, "key")
+    assert Kronk::DataSet.match_data_item("key", :key)
+
+    assert Kronk::DataSet.match_data_item(/key/, "foo_key")
+    assert !Kronk::DataSet.match_data_item("foo_key", /key/)
+
+    assert Kronk::DataSet.match_data_item(nil, "foo_key")
+    assert !Kronk::DataSet.match_data_item("foo_key", nil)
+  end
+
+
+  def test_hash_each_data_item
+    hash = {
+      :a => 1,
+      :b => 2,
+      :c => 3
+    }
+
+    keys = []
+    values = []
+
+    Kronk::DataSet.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_array_each_data_item
+    ary = [:a, :b, :c]
+
+    keys = []
+    values = []
+
+    Kronk::DataSet.each_data_item ary do |key, val|
+      keys << key
+      values << val
+    end
+
+    assert_equal [0,1,2], keys
+    assert_equal ary, values
+  end
+end

data/test/test_diff.rb

@@ -0,0 +1,427 @@
+require 'test/test_helper'
+
+class TestDiff < Test::Unit::TestCase
+
+  def setup
+    @diff = Kronk::Diff.new mock_302_response, mock_301_response
+  end
+
+
+  def test_new_from_data
+    other_data = {:foo => :bar}
+
+    diff = Kronk::Diff.new_from_data mock_data, other_data
+
+    assert_equal Kronk::Diff.ordered_data_string(mock_data), diff.str1
+    assert_equal Kronk::Diff.ordered_data_string(other_data), diff.str2
+  end
+
+
+  def test_ordered_data_string
+    expected = <<STR
+{
+"acks" => [
+ [
+  56,
+  78
+  ],
+ [
+  "12",
+  "34"
+  ]
+ ],
+"root" => [
+ [
+  "B1",
+  "B2"
+  ],
+ [
+  "A1",
+  "A2"
+  ],
+ [
+  "C1",
+  "C2",
+  [
+   "C3a",
+   "C3b"
+   ]
+  ],
+ {
+  "test" => [
+   [
+    "D1a\\nContent goes here",
+    "D1b"
+    ],
+   "D2"
+   ],
+  :tests => [
+   "D3a",
+   "D3b"
+   ]
+  }
+ ],
+"subs" => [
+ "a",
+ "b"
+ ],
+"tests" => {
+ "test" => [
+  [
+   1,
+   2
+   ],
+  2.123
+  ],
+ :foo => :bar
+ }
+}
+STR
+
+    assert_equal expected.strip, Kronk::Diff.ordered_data_string(mock_data)
+  end
+
+
+  def test_ordered_data_string_struct
+    expected = <<STR
+{
+"acks" => [
+ [
+  Fixnum,
+  Fixnum
+  ],
+ [
+  String,
+  String
+  ]
+ ],
+"root" => [
+ [
+  String,
+  String
+  ],
+ [
+  String,
+  String
+  ],
+ [
+  String,
+  String,
+  [
+   String,
+   String
+   ]
+  ],
+ {
+  "test" => [
+   [
+    String,
+    String
+    ],
+   String
+   ],
+  :tests => [
+   String,
+   String
+   ]
+  }
+ ],
+"subs" => [
+ String,
+ String
+ ],
+"tests" => {
+ "test" => [
+  [
+   Fixnum,
+   Fixnum
+   ],
+  Float
+  ],
+ :foo => Symbol
+ }
+}
+STR
+
+    assert_equal expected.strip,
+                  Kronk::Diff.ordered_data_string(mock_data, true)
+  end
+
+
+  def test_create_diff_inverted
+    @diff = Kronk::Diff.new mock_301_response, mock_302_response
+    assert_equal diff_301_302, @diff.create_diff
+  end
+
+
+  def test_create_diff
+    assert_equal diff_302_301, @diff.create_diff
+    assert_equal @diff.to_a, @diff.create_diff
+    assert_equal @diff.to_a, @diff.diff_array
+  end
+
+
+  def test_create_diff_no_match
+    str1 = "this is str1\nthat shouldn't\nmatch\nany of\nthe\nlines"
+    str2 = "this is str2\nwhich should\nalso not match\nany\nof the\nstr1 lines"
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal [[str1.split("\n"), str2.split("\n")]], diff.create_diff
+  end
+
+
+  def test_create_diff_all_match
+    str1 = "this is str\nthat should\nmatch\nall of\nthe\nlines"
+    str2 = "this is str\nthat should\nmatch\nall of\nthe\nlines"
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal str1.split("\n"), diff.create_diff
+  end
+
+
+  def test_create_diff_all_added
+    str1 = "this is str\nthat should\nmatch\nall of\nthe\nlines"
+    str2 = "this is str\nmore stuff\nthat should\nmatch\nall of\nthe\nold lines"
+
+    expected = [
+      "this is str",
+      [[], ["more stuff"]],
+      "that should",
+      "match",
+      "all of",
+      "the",
+      [["lines"], ["old lines"]]
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_create_diff_all_removed
+    str1 = "this is str\nmore stuff\nthat should\nmatch\nall of\nthe\nold lines"
+    str2 = "this is str\nthat should\nmatch\nall of\nthe\nlines"
+
+    expected = [
+      "this is str",
+      [["more stuff"], []],
+      "that should",
+      "match",
+      "all of",
+      "the",
+      [["old lines"], ["lines"]]
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_create_diff_multi_removed
+    str1 = "this str\nmore stuff\nagain\nshould\nmatch\nall of\nthe\nold lines"
+    str2 = "this str\nthat should\nmatch\nall of\nthe\nlines"
+
+    expected = [
+      "this str",
+      [["more stuff", "again", "should"], ["that should"]],
+      "match",
+      "all of",
+      "the",
+      [["old lines"], ["lines"]]
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_create_diff_long_end_diff
+    str1 = "this str\nis done"
+    str2 = "this str\nthat should\nmatch\nall of\nthe\nlines"
+
+    expected = [
+      "this str",
+      [["is done"], ["that should", "match", "all of", "the", "lines"]],
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_create_diff_long_end_diff_inverted
+    str1 = "this str\nthat should\nmatch\nall of\nthe\nlines"
+    str2 = "this str\nis done"
+
+    expected = [
+      "this str",
+      [["that should", "match", "all of", "the", "lines"], ["is done"]],
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_create_diff_long
+    str1 = "this str"
+    str2 = "this str\nthat should\nmatch\nall of\nthe\nlines"
+
+    expected = [
+      "this str",
+      [[], ["that should", "match", "all of", "the", "lines"]],
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_create_diff_long_inverted
+    str1 = "this str\nthat should\nmatch\nall of\nthe\nlines"
+    str2 = "this str"
+
+    expected = [
+      "this str",
+      [["that should", "match", "all of", "the", "lines"], []],
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_formatted
+    assert_equal diff_302_301_str, @diff.formatted
+  end
+
+
+  def test_formatted_color
+    assert_equal diff_302_301_color, @diff.formatted(:color_diff)
+
+    @diff.format = :color_diff
+    assert_equal diff_302_301_color, @diff.formatted
+  end
+
+
+  def test_formatted_join_char
+    expected = diff_302_301_str.gsub(/\n/, "\r\n")
+    assert_equal expected, @diff.formatted(:ascii_diff, "\r\n")
+  end
+
+
+  def test_formatted_block
+    str_diff = @diff.formatted do |item|
+      if Array === item
+        item[0].map!{|str| "<<<302<<< #{str}"}
+        item[1].map!{|str| ">>>301>>> #{str}"}
+        item
+      else
+        item.to_s
+      end
+    end
+
+    expected = diff_302_301_str.gsub(/^\+/, ">>>301>>>")
+    expected = expected.gsub(/^\-/, "<<<302<<<")
+    expected = expected.gsub(/^\s\s/, "")
+
+    assert_equal expected, str_diff
+  end
+
+  private
+
+  def diff_302_301
+    [[["HTTP/1.1 302 Found", "Location: http://igoogle.com/"],
+      ["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: 260"], ["Content-Length: 219"]],
+    "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>"],
+      ["<TITLE>301 Moved</TITLE></HEAD><BODY>", "<H1>301 Moved</H1>"]],
+    "The document has moved", "<A HREF=\"http://www.google.com/\">here</A>.",
+    [["<A HREF=\"http://igoogle.com/\">here</A>."], []],
+    "</BODY></HTML>"]
+  end
+
+  def diff_301_302
+    [[["HTTP/1.1 301 Moved Permanently", "Location: http://www.google.com/"],
+      ["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: 219"], ["Content-Length: 260"]],
+    "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>"],
+      ["<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>"]
+  end
+
+
+  def diff_302_301_str
+    str = <<STR
+- HTTP/1.1 302 Found
+- Location: http://igoogle.com/
++ 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: 260
++ Content-Length: 219
+  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>
++ <TITLE>301 Moved</TITLE></HEAD><BODY>
++ <H1>301 Moved</H1>
+  The document has moved
+  <A HREF="http://www.google.com/">here</A>.
+- <A HREF="http://igoogle.com/">here</A>.
+  </BODY></HTML>
+STR
+    str.strip
+  end
+
+  def diff_302_301_color
+    str = <<STR
+\033[31mHTTP/1.1 302 Found\033[0m
+\033[31mLocation: http://igoogle.com/\033[0m
+\033[32mHTTP/1.1 301 Moved Permanently\033[0m
+\033[32mLocation: http://www.google.com/\033[0m
+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
+\033[31mContent-Length: 260\033[0m
+\033[32mContent-Length: 219\033[0m
+X-XSS-Protection: 1; mode=block
+
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+\033[31m<TITLE>302 Found</TITLE></HEAD><BODY>\033[0m
+\033[31m<H1>302 Found</H1>\033[0m
+\033[32m<TITLE>301 Moved</TITLE></HEAD><BODY>\033[0m
+\033[32m<H1>301 Moved</H1>\033[0m
+The document has moved
+<A HREF="http://www.google.com/">here</A>.
+\033[31m<A HREF="http://igoogle.com/">here</A>.\033[0m
+</BODY></HTML>
+STR
+    str.strip
+  end
+end