kronk 1.2.5 → 1.3.0

data/lib/yzma/randomizer.rb

@@ -0,0 +1,54 @@
+class Yzma
+
+  ##
+  # Randomizes params, data, and headers for Yzma requests.
+
+  class Randomizer
+
+    def initialize
+      @options = {}
+    end
+
+
+    def to_options
+      @options.dup
+    end
+
+
+    def randomize_param name, values, options={}
+      @options[:query] ||= {}
+      assign_random @options[:query], name, values, options
+    end
+
+
+    def randomize_data name, values, options={}
+      @options[:data] ||= {}
+      assign_random @options[:data], name, values, options
+    end
+
+
+    def randomize_header name, values, options={}
+      @options[:headers] ||= {}
+      assign_random @options[:headers], name, values, options
+    end
+
+
+    def assign_random obj, key, values, options={}
+      random_value = pick_random values, options
+      obj[key] = random_value if random_value
+    end
+
+
+    def pick_random val, options={}
+      val = File.readlines val if String === val
+      val = val.to_a           if Range === val
+
+      val << ""  if options[:allow_blank]
+      val << nil if options[:optional]
+
+      return if val.empty?
+
+      val[rand(val.length)]
+    end
+  end
+end

data/lib/yzma/report.rb

@@ -0,0 +1,47 @@
+class Yzma
+
+  ##
+  # Used to build and display Yzma reports.
+  # Other report types can be created by inheriting this class and
+  # overridding the 'write' method to use @data as desired.
+
+  class Report
+
+    attr_accessor :data, :header, :footer, :name
+
+    def initialize name
+      @name = name
+      @data = []
+      @header = ["#{@name} #{Time.now}"]
+      @footer = ["\n"]
+    end
+
+
+    ##
+    # Adds data and a related piece of data identification to
+    # the report.
+
+    def add identifier, data
+      @data << [identifier, data]
+    end
+
+
+    ##
+    # Generates and writes the report to the given IO instance.
+    # Defaults to STDOUT.
+
+    def write io=$stdout
+      io << @header.join("\n")
+
+      @data.each do |identifier, data|
+        if block_given?
+          io << yield(identifier, data)
+        else
+          io << "\n#{identifier.inspect}\n#{data.inspect}\n"
+        end
+      end
+
+      io << @footer.join("\n")
+    end
+  end
+end

data/test/test_assertions.rb

@@ -0,0 +1,93 @@
+require 'test/test_helper'
+require 'lib/kronk/test/assertions'
+
+class TestAssertions < Test::Unit::TestCase
+  include Kronk::Test::Assertions
+
+  def setup
+    @array = [:a, :b, {:foo => "bar", :bar => [:a, :b, {:foo => "other"}]}, :c]
+    @hash  = {:foo => "bar", :bar => [:a, :b, {:foo => "other"}], :a => [1,2,3]}
+  end
+
+
+  def test_assert_data_at
+    assert_data_at @array, "2/bar/2"
+    assert_data_at @hash, "bar/2"
+  end
+
+
+  def test_assert_data_at_failure
+    self.expects(:assert).with(false, "OOPS")
+    assert_data_at @array, "foobar", "OOPS"
+  end
+
+
+  def test_assert_no_data_at
+    assert_no_data_at @array, "foobar"
+  end
+
+
+  def test_assert_no_data_at_failure
+    self.expects(:assert).with(false, "OOPS")
+    assert_no_data_at @array, "**/foo", "OOPS"
+  end
+
+
+  def test_assert_data_at_equal
+    assert_data_at_equal @array, "2/bar/2/foo", "other"
+    assert_data_at_equal @hash, "bar/2/foo", "other"
+  end
+
+
+  def test_assert_data_at_equal_failure
+    self.expects(:assert).with(false, "OOPS")
+    self.expects(:assert_equal).with("nodice", nil, "OOPS")
+    assert_data_at_equal @array, "foobar", "nodice", "OOPS"
+  end
+
+
+  def test_assert_data_at_not_equal
+    assert_data_at_not_equal @array, "foobar", "thing"
+  end
+
+
+  def test_assert_data_at_not_equal_failure
+    self.expects(:assert_not_equal).with("bar", "bar", "OOPS")
+    assert_data_at_not_equal @array, "**/foo", "bar", "OOPS"
+  end
+
+
+  def test_assert_equal_responses
+    io        = StringIO.new mock_resp("200_response.json")
+    mock_resp = Kronk::Response.read_new io
+
+    Kronk::Request.expects(:retrieve).times(2).
+      with("host.com", :foo => "bar").returns mock_resp
+
+    assert_equal_responses "host.com", "host.com", :foo => "bar"
+  end
+
+
+  def test_assert_equal_responses_failure
+    mock_resp1 = Kronk::Response.read_new \
+                  StringIO.new mock_resp("200_response.json")
+
+    mock_resp2 = Kronk::Response.read_new \
+                  StringIO.new mock_resp("301_response.txt")
+
+    Kronk::Request.expects(:retrieve).
+      with("host1.com", :foo => "bar").returns mock_resp1
+
+    Kronk::Request.expects(:retrieve).
+      with("host2.com", :foo => "bar").returns mock_resp2
+
+    left  = Kronk::Diff.ordered_data_string mock_resp1.selective_data
+    right = mock_resp2.body
+
+    assert_not_equal left, right
+
+    self.expects(:assert_equal).with left, right
+
+    assert_equal_responses "host1.com", "host2.com", :foo => "bar"
+  end
+end

data/test/test_core_ext.rb

@@ -0,0 +1,74 @@
+require 'test/test_helper'
+require 'lib/kronk/test/core_ext'
+
+class TestCoreExt < Test::Unit::TestCase
+
+  def setup
+    @array = [:a, :b, {:foo => "bar", :bar => [:a, :b, {:foo => "other"}]}, :c]
+    @hash  = {:foo => "bar", :bar => [:a, :b, {:foo => "other"}], :a => [1,2,3]}
+  end
+
+
+  def test_has_path_array
+    assert @array.has_path?("**/foo")
+    assert @array.has_path?("**/foo=other")
+    assert_nil @array.has_path?("**/foobar")
+  end
+
+
+  def test_has_path_hash
+    assert @hash.has_path?("**/foo")
+    assert @hash.has_path?("**/foo=other")
+    assert_nil @hash.has_path?("**/foobar")
+  end
+
+
+  def test_find_data_array
+    out = @array.find_data "**/foo"
+    assert_equal({[2, :foo] => "bar", [2, :bar, 2, :foo] => "other"}, out)
+  end
+
+
+  def test_find_data_array_empty
+    out = @array.find_data "**/foobar"
+    assert_equal({}, out)
+  end
+
+
+  def test_find_data_array_block
+    collected = []
+
+    @array.find_data "**/foo" do |data, key, path|
+      collected << [data, key, path]
+    end
+
+    assert_equal 2, collected.length
+    assert collected.include?([@array[2], :foo, [2, :foo]])
+    assert collected.include?([@array[2][:bar][2], :foo, [2, :bar, 2, :foo]])
+  end
+
+
+  def test_find_data_hash
+    out = @hash.find_data "**/foo"
+    assert_equal({[:foo] => "bar", [:bar, 2, :foo] => "other"}, out)
+  end
+
+
+  def test_find_data_hash_empty
+    out = @hash.find_data "**/foobar"
+    assert_equal({}, out)
+  end
+
+
+  def test_find_data_hash_block
+    collected = []
+
+    @hash.find_data "**/foo" do |data, key, path|
+      collected << [data, key, path]
+    end
+
+    assert_equal 2, collected.length
+    assert collected.include?([@hash, :foo, [:foo]])
+    assert collected.include?([@hash[:bar][2], :foo, [:bar, 2, :foo]])
+  end
+end

data/test/test_data_set.rb

@@ -284,7 +284,7 @@ class TestDataSet < Test::Unit::TestCase
 
   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
+    key, value, rec, data_path = @dataset.parse_data_path data_path
 
     assert_equal "key1", key
     assert_nil value
@@ -295,7 +295,7 @@ class TestDataSet < Test::Unit::TestCase
 
   def test_parse_data_path_escaped_slash
     key, value, rec, data_path =
-      Kronk::DataSet.parse_data_path \
+      @dataset.parse_data_path \
         "key\\/2=value/key*=*value/**=value2/key\\=thing"
 
     assert_equal "key/2", key
@@ -306,9 +306,9 @@ class TestDataSet < Test::Unit::TestCase
 
 
   def test_parse_data_path_wildcard
-    key, value, rec, data_path = Kronk::DataSet.parse_data_path "*/key1?"
+    key, value, rec, data_path = @dataset.parse_data_path "*/key1?"
 
-    assert_equal(/^(.*)$/, key)
+    assert_equal(/^(.*)$/i, key)
     assert_nil value
     assert !rec, "Should not return recursive = true"
     assert_equal "key1?", data_path
@@ -317,7 +317,7 @@ class TestDataSet < Test::Unit::TestCase
 
   def test_parse_data_path_recursive_value
     key, value, rec, data_path =
-      Kronk::DataSet.parse_data_path "**=value2/key\\=thing"
+      @dataset.parse_data_path "**=value2/key\\=thing"
 
     assert_equal(/.*/, key)
     assert_equal "value2", value
@@ -328,7 +328,7 @@ class TestDataSet < Test::Unit::TestCase
 
   def test_parse_data_path_recursive
     data_path = "**"
-    key, value, rec, data_path = Kronk::DataSet.parse_data_path "**"
+    key, value, rec, data_path = @dataset.parse_data_path "**"
 
     assert_equal(/.*/, key)
     assert_nil value
@@ -339,7 +339,7 @@ class TestDataSet < Test::Unit::TestCase
 
   def test_parse_data_path_recursive_key
     data_path = "**"
-    key, value, rec, data_path = Kronk::DataSet.parse_data_path "**/key"
+    key, value, rec, data_path = @dataset.parse_data_path "**/key"
 
     assert_equal "key", key
     assert_nil value
@@ -349,7 +349,7 @@ class TestDataSet < Test::Unit::TestCase
 
 
   def test_parse_data_path_escaped_equal
-    key, value, rec, data_path = Kronk::DataSet.parse_data_path "key\\=thing"
+    key, value, rec, data_path = @dataset.parse_data_path "key\\=thing"
 
     assert_equal "key=thing", key
     assert_nil value
@@ -359,9 +359,9 @@ class TestDataSet < Test::Unit::TestCase
 
 
   def test_parse_data_path_last
-    key, value, rec, data_path = Kronk::DataSet.parse_data_path "key*"
+    key, value, rec, data_path = @dataset.parse_data_path "key*"
 
-    assert_equal(/^(key.*)$/, key)
+    assert_equal(/^(key.*)$/i, key)
     assert_nil value
     assert !rec, "Should not return recursive = true"
     assert_equal nil, data_path
@@ -369,7 +369,7 @@ class TestDataSet < Test::Unit::TestCase
 
 
   def test_parse_data_path_empty
-    key, value, rec, data_path = Kronk::DataSet.parse_data_path ""
+    key, value, rec, data_path = @dataset.parse_data_path ""
 
     assert_equal nil, key
     assert_nil value
@@ -379,25 +379,29 @@ class TestDataSet < Test::Unit::TestCase
 
 
   def test_parse_path_item
-    assert_equal "foo", Kronk::DataSet.parse_path_item("foo")
+    assert_equal "foo", @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)$/i, @dataset.parse_path_item("foo*bar"))
+    assert_equal(/^(foo|bar)$/i, @dataset.parse_path_item("foo|bar"))
+    assert_equal(/^(foo.?bar)$/i, @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)$/i, @dataset.parse_path_item("foo?\\?bar"))
+    assert_equal(/^(key.*)$/i, @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")
+    assert_equal "foo*bar", @dataset.parse_path_item("foo\\*bar")
+    assert_equal "foo|bar", @dataset.parse_path_item("foo\\|bar")
+    assert_equal "foo?bar", @dataset.parse_path_item("foo\\?bar")
+
+    assert_equal 1..3, @dataset.parse_path_item("1..3")
+    assert_equal 1...3, @dataset.parse_path_item("1...3")
+    assert_equal 3...6, @dataset.parse_path_item("3,3")
   end
 
 
   def test_yield_data_points
     keys = []
 
-    Kronk::DataSet.yield_data_points @data, /key/ do |data, key|
+    @dataset.yield_data_points @data, /key/ do |data, key|
       keys << key.to_s
       assert_equal @data, data
     end
@@ -410,7 +414,7 @@ class TestDataSet < Test::Unit::TestCase
     keys = []
     data_points = []
 
-    Kronk::DataSet.yield_data_points @data, :findme, nil, true do |data, key|
+    @dataset.yield_data_points @data, :findme, nil, true do |data, key|
       keys << key.to_s
       data_points << data
     end
@@ -430,7 +434,7 @@ class TestDataSet < Test::Unit::TestCase
     keys = []
     data_points = []
 
-    Kronk::DataSet.yield_data_points @data, nil, "findme" do |data, key|
+    @dataset.yield_data_points @data, nil, "findme" do |data, key|
       keys << key.to_s
       data_points << data
     end
@@ -438,7 +442,7 @@ class TestDataSet < Test::Unit::TestCase
     assert keys.empty?
     assert data_points.empty?
 
-    Kronk::DataSet.yield_data_points @data, nil, "findme", true do |data, key|
+    @dataset.yield_data_points @data, nil, "findme", true do |data, key|
       keys << key.to_s
       data_points << data
     end
@@ -449,14 +453,19 @@ class TestDataSet < Test::Unit::TestCase
 
 
   def test_match_data_item
-    assert Kronk::DataSet.match_data_item(:key, "key")
-    assert Kronk::DataSet.match_data_item("key", :key)
+    assert @dataset.match_data_item(:key, "key")
+    assert @dataset.match_data_item("key", :key)
+
+    assert @dataset.match_data_item(/key/, "foo_key")
+    assert !@dataset.match_data_item("foo_key", /key/)
+    assert @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 @dataset.match_data_item(nil, "foo_key")
+    assert !@dataset.match_data_item("foo_key", nil)
 
-    assert Kronk::DataSet.match_data_item(nil, "foo_key")
-    assert !Kronk::DataSet.match_data_item("foo_key", nil)
+    assert @dataset.match_data_item(1..3, 1)
+    assert !@dataset.match_data_item(1, 1..3)
+    assert @dataset.match_data_item(1..3, 1..3)
   end
 
 
@@ -470,7 +479,7 @@ class TestDataSet < Test::Unit::TestCase
     keys = []
     values = []
 
-    Kronk::DataSet.each_data_item hash do |key, val|
+    @dataset.each_data_item hash do |key, val|
       keys << key
       values << val
     end
@@ -486,7 +495,7 @@ class TestDataSet < Test::Unit::TestCase
     keys = []
     values = []
 
-    Kronk::DataSet.each_data_item ary do |key, val|
+    @dataset.each_data_item ary do |key, val|
       keys << key
       values << val
     end