kronk 1.6.2 → 1.7.0

data/test/test_player.rb

@@ -27,6 +27,8 @@ class TestPlayer < Test::Unit::TestCase
 
 
   def setup
+    Kronk::Player.async = false
+
     @io        = MockPipe.new
     @parser    = MockParser
     @output    = MockOutput
@@ -87,13 +89,6 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_queue_req
-    @player.queue_req :first_item
-    @player.queue_req :second_item
-    assert_equal [:first_item, :second_item], @player.queue
-  end
-
-
   def test_from_io
     @player.from_io "mock"
     assert_equal "mock", @player.input.io
@@ -105,18 +100,13 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_output_results
-    @player.output.expects(:completed).with().returns "FINISHED"
-    assert_equal "FINISHED", @player.output_results
-  end
-
-
   def test_finished_false
     @player.number = nil
 
     @player.queue.clear
     @player.count = 2
-    @player.input.stubs(:eof?).returns false
+    @player.reader_thread = "mock thread"
+    @player.reader_thread.stubs(:alive?).returns true
     assert !@player.finished?
 
     @player.queue << "test"
@@ -129,13 +119,6 @@ class TestPlayer < Test::Unit::TestCase
     @player.input.stubs(:eof?).returns true
     assert !@player.finished?
 
-    @player.count = 4
-    @player.queue.clear
-    @player.input.stubs(:eof?).returns true
-    @player.reader_thread = "mock thread"
-    @player.reader_thread.expects(:alive?).returns true
-    assert !@player.finished?
-
     @player.queue << "test"
     @player.input.stubs(:eof?).returns true
     @player.reader_thread.stubs(:alive?).returns false
@@ -153,7 +136,12 @@ class TestPlayer < Test::Unit::TestCase
     @player.number = nil
     @player.count  = 1
     @player.queue.clear
-    @player.input.stubs(:eof?).returns true
+    @player.reader_thread = "mock thread"
+    @player.reader_thread.expects(:alive?).returns false
+    assert @player.finished?
+
+    @player.count = 4
+    @player.queue.clear
     @player.reader_thread = "mock thread"
     @player.reader_thread.expects(:alive?).returns false
     assert @player.finished?
@@ -161,8 +149,7 @@ class TestPlayer < Test::Unit::TestCase
     @player.number = 10
     @player.count  = 1
     @player.queue.clear
-    @player.input.stubs(:eof?).returns true
-    @player.reader_thread.expects(:alive?).returns false
+    @player.reader_thread = nil
     assert @player.finished?
   end
 
@@ -177,6 +164,9 @@ class TestPlayer < Test::Unit::TestCase
 
 
   def test_compare
+    @player.output.expects :start
+    @player.output.expects :completed
+
     @player.concurrency  = 3
     @player.input.parser = Kronk::Player::RequestParser
     @player.input.io << "/req3\n/req4\n/req5\n"
@@ -215,11 +205,14 @@ class TestPlayer < Test::Unit::TestCase
 
 
   def test_request
-    @player.concurrency  = 3
-    @player.input.parser = Kronk::Player::RequestParser
-    @player.input.io << "/req3\n/req4\n/req5\n"
-    @player.input.io.rewind
-    @player.input.io.close_write
+    @player.concurrency = 3
+
+    paths = %w{/req3 /req4 /req5}
+
+    @player.on :input do
+      @player.stop_input! if paths.empty?
+      {:uri_suffix => paths.shift}
+    end
 
     @player.queue.concat [{:uri_suffix => "/req1"}, {:uri_suffix => "/req2"}]
 
@@ -238,20 +231,26 @@ class TestPlayer < Test::Unit::TestCase
         :query      => "foo=bar"
     end
 
-    @player.request "example.com", :query => "foo=bar"
+    result_calls = 0
 
-    assert_equal 5, @player.output.result_calls
+    @player.request "example.com", :query => "foo=bar" do |kronk, err|
+      result_calls += 1
+    end
+
+    assert_equal 5, result_calls
   end
 
 
-  def test_process_queue_interrupted
+  def test_run_interrupted
     @player.concurrency = 0
 
     @player.output.expects :start
     @player.output.expects :completed
 
     thread = Thread.new do
-      @player.process_queue
+      @player.run do |item, mutex|
+        sleep 0.1
+      end
     end
 
     sleep 0.1
@@ -270,9 +269,6 @@ class TestPlayer < Test::Unit::TestCase
     @player.queue.concat requests.dup
     @player.input.io.close
 
-    @player.output.expects :start
-    @player.output.expects :completed
-
     start     = Time.now
     processed = []
 
@@ -293,9 +289,6 @@ class TestPlayer < Test::Unit::TestCase
 
   def test_process_queue_from_io
     @player.concurrency = 10
-    @player.output.expects :start
-    @player.output.expects :completed
-
     @player.input.parser.stubs(:start_new?).returns true
     @player.input.parser.stubs(:start_new?).with("").returns false
 
@@ -352,13 +345,13 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_try_fill_queue_from_input
+  def test_start_input_from_input
     @player.input.stubs(:get_next).returns "mock_request"
 
     @player.concurrency = 5
     @player.number      = 20
 
-    thread = @player.try_fill_queue
+    thread = @player.start_input!
     assert_equal Thread, thread.class
 
     sleep 0.2
@@ -374,14 +367,14 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_try_fill_queue_from_last
+  def test_start_input_from_last
     @player.input.stubs(:get_next).returns nil
     @player.input.stubs(:eof?).returns false
 
     @player.concurrency = 5
     @player.queue << "mock_request"
 
-    thread = @player.try_fill_queue
+    thread = @player.start_input!
     assert_equal Thread, thread.class
 
     sleep 0.2
@@ -397,13 +390,13 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_try_fill_queue_no_input
+  def test_start_input_no_input
     @player.input.stubs(:eof?).returns true
 
     @player.concurrency = 5
     @player.queue << "mock_request"
 
-    thread = @player.try_fill_queue
+    thread = @player.start_input!
     assert_equal Thread, thread.class
 
     sleep 0.2
@@ -414,27 +407,27 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_next_request
+  def test_next_input
     @player.input.expects(:get_next).returns "NEXT ITEM"
-    assert_equal "NEXT ITEM", @player.next_request
+    assert_equal "NEXT ITEM", @player.trigger(:input)
 
     @player.input.expects(:get_next).returns nil
     @player.queue.concat ["FIRST ITEM", "QUEUE REPEAT"]
-    assert_equal "QUEUE REPEAT", @player.next_request
+    assert_equal "QUEUE REPEAT", @player.trigger(:input)
 
     @player.input.expects(:get_next).returns nil
     @player.queue.clear
     @player.instance_variable_set "@last_req", "LAST REQ"
-    assert_equal "LAST REQ", @player.next_request
+    assert_equal "LAST REQ", @player.trigger(:input)
 
     @player.input.expects(:get_next).returns nil
     @player.queue.clear
     @player.instance_variable_set "@last_req", nil
-    assert_equal Hash.new, @player.next_request
+    assert_equal Hash.new, @player.trigger(:input)
   end
 
 
-  def test_process_compare
+  def test_process_compare_one
     mock_thread = "mock_thread"
     Thread.expects(:new).twice.yields.returns mock_thread
     mock_thread.expects(:join).twice
@@ -462,14 +455,14 @@ class TestPlayer < Test::Unit::TestCase
       true
     end
 
-    @player.process_compare "example.com", "beta-example.com",
-      :uri_suffix => "/test", :include_headers => true
+    opts = {:uri_suffix => "/test", :include_headers => true}
+    @player.process_one opts, :compare, "example.com", "beta-example.com"
 
     assert @got_results, "Expected output to get results but didn't"
   end
 
 
-  def test_process_compare_error
+  def test_process_one_compare_error
     @got_results = []
 
     @player.output.expects(:error).times(3).with do |error, kronk, mutex|
@@ -481,27 +474,31 @@ class TestPlayer < Test::Unit::TestCase
 
     errs = [Kronk::Exception, Kronk::Response::MissingParser, Errno::ECONNRESET]
     errs.each do |eklass|
-      Kronk.any_instance.expects(:compare).raises eklass
+      Kronk.any_instance.expects(:compare).
+        with("example.com", "beta-example.com").
+        raises eklass
 
-      @player.process_compare "example.com", "beta-example.com",
-        :uri_suffix => "/test", :include_headers => true
+      opts = {:uri_suffix => "/test", :include_headers => true}
+      @player.process_one opts, :compare, "example.com", "beta-example.com"
     end
 
     assert_equal errs, @got_results, "Expected output to get errors but didn't"
   end
 
 
-  def test_process_compare_error_not_caught
-    Kronk.any_instance.expects(:compare).raises RuntimeError
+  def test_process_one_compare_error_not_caught
+    Kronk.any_instance.expects(:compare).
+      with("example.com", "beta-example.com").
+      raises RuntimeError
 
     assert_raises RuntimeError do
-      @player.process_compare "example.com", "beta-example.com",
-        :uri_suffix => "/test", :include_headers => true
+      opts = {:uri_suffix => "/test", :include_headers => true}
+      @player.process_one opts, :compare, "example.com", "beta-example.com"
     end
   end
 
 
-  def test_process_request
+  def test_process_one_request
     resp = Kronk::Response.new mock_resp("200_response.json")
     resp.parser = JSON
 
@@ -519,14 +516,14 @@ class TestPlayer < Test::Unit::TestCase
       true
     end
 
-    @player.process_request "example.com",
-      :uri_suffix => "/test", :include_headers => true
+    opts = {:uri_suffix => "/test", :include_headers => true}
+    @player.process_one opts, :request, "example.com"
 
     assert @got_results, "Expected output to get results but didn't"
   end
 
 
-  def test_process_request_error
+  def test_process_one_request_error
     @got_results = []
 
     @player.output.expects(:error).times(3).with do |error, kronk, mutex|
@@ -538,22 +535,24 @@ class TestPlayer < Test::Unit::TestCase
 
     errs = [Kronk::Exception, Kronk::Response::MissingParser, Errno::ECONNRESET]
     errs.each do |eklass|
-      Kronk.any_instance.expects(:retrieve).raises eklass
+      Kronk.any_instance.expects(:request).with("example.com").
+        raises eklass
 
-      @player.process_request "example.com",
-        :uri_suffix => "/test", :include_headers => true
+      opts = {:uri_suffix => "/test", :include_headers => true}
+      @player.process_one opts, :request, "example.com"
     end
 
     assert_equal errs, @got_results, "Expected output to get errors but didn't"
   end
 
 
-  def test_process_request_error_not_caught
-    Kronk.any_instance.expects(:retrieve).raises RuntimeError
+  def test_process_one_request_error_not_caught
+    Kronk.any_instance.expects(:request).with("example.com").
+      raises RuntimeError
 
     assert_raises RuntimeError do
-      @player.process_request "example.com",
-        :uri_suffix => "/test", :include_headers => true
+      opts = {:uri_suffix => "/test", :include_headers => true}
+      @player.process_one opts, :request, "example.com"
     end
   end
 

data/test/test_request.rb

@@ -13,6 +13,24 @@ class TestRequest < Test::Unit::TestCase
   end
 
 
+  def test_parse_url
+    raw = "https://example.com/foobar?foo=bar"
+    req = Kronk::Request.parse(raw)
+
+    assert_equal Kronk::Request, req.class
+    assert_equal URI.parse("https://example.com/foobar?foo=bar"), req.uri
+  end
+
+
+  def test_parse_url_path
+    raw = "/foobar?foo=bar"
+    req = Kronk::Request.parse(raw)
+
+    assert_equal Kronk::Request, req.class
+    assert_equal URI.parse("http://localhost:3000/foobar?foo=bar"), req.uri
+  end
+
+
   def test_parse_invalid
     assert_raises Kronk::Request::ParseError do
       Kronk::Request.parse "thing\nfoo\n"
@@ -43,6 +61,13 @@ class TestRequest < Test::Unit::TestCase
   end
 
 
+  def test_parse_to_hash_url
+    expected = {:host => "http://example.com", :uri_suffix => "/foobar?foo=bar"}
+    assert_equal expected,
+      Kronk::Request.parse_to_hash("http://example.com/foobar?foo=bar")
+  end
+
+
   def test_parse_to_hash_invalid
     assert_nil Kronk::Request.parse_to_hash("thing\nfoo\n")
     assert_nil Kronk::Request.parse_to_hash("")
@@ -351,7 +376,7 @@ class TestRequest < Test::Unit::TestCase
 
   def test_retrieve_proxy
     proxy = {
-      :address  => "proxy.com",
+      :host     => "proxy.com",
       :username => "john",
       :password => "smith"
     }
@@ -378,12 +403,12 @@ class TestRequest < Test::Unit::TestCase
 
 
   def test_proxy_nil
-    assert_equal Net::HTTP, Kronk::Request.new("host.com").use_proxy(nil)
+    assert_equal Net::HTTP, Kronk::Request.new("host.com").http_proxy(nil)
   end
 
 
   def test_proxy_string
-    proxy_class = Kronk::Request.new("host.com").use_proxy("myproxy.com:80")
+    proxy_class = Kronk::Request.new("host.com").http_proxy("myproxy.com:80")
 
     assert_equal "myproxy.com",
       proxy_class.instance_variable_get("@proxy_address")
@@ -396,7 +421,7 @@ class TestRequest < Test::Unit::TestCase
 
 
   def test_proxy_no_port
-    proxy_class = Kronk::Request.new("host.com").use_proxy("myproxy.com")
+    proxy_class = Kronk::Request.new("host.com").http_proxy("myproxy.com")
 
     assert_equal "myproxy.com",
       proxy_class.instance_variable_get("@proxy_address")
@@ -410,12 +435,12 @@ class TestRequest < Test::Unit::TestCase
 
   def test_proxy_hash
     req = Kronk::Request.new "http://example.com",
-            :proxy => { :address  => "myproxy.com",
+            :proxy => { :host     => "myproxy.com",
                         :port     => 8080,
                         :username => "john",
                         :password => "smith" }
 
-    proxy_class = req.instance_variable_get "@HTTP"
+    proxy_class = req.http_proxy req.proxy[:host], req.proxy
 
     assert_equal "myproxy.com",
       proxy_class.instance_variable_get("@proxy_address")

data/test/test_request_parser.rb

@@ -5,7 +5,13 @@ class TestRequestParser < Test::Unit::TestCase
   def test_start_new
     assert Kronk::Player::RequestParser.start_new?("/foobar\r\n")
     assert Kronk::Player::RequestParser.start_new?("GET /foobar\r\n")
-    assert !Kronk::Player::RequestParser.start_new?("http://example.com\r\n")
+    assert Kronk::Player::RequestParser.start_new?("http://example.com\r\n")
+    assert Kronk::Player::RequestParser.start_new?("https://example.com\r\n")
+    assert Kronk::Player::RequestParser.start_new?("https://foo.com/\r\n")
+    assert Kronk::Player::RequestParser.start_new?("/\r\n")
+    assert Kronk::Player::RequestParser.start_new?("https://foo.com/bar\r\n")
+    assert Kronk::Player::RequestParser.start_new?(
+      "10.1.8.10 - - [20/Sep/2011:20:57:54 +0000] \"GET /users/d7399ed0-c5f1-012e-cf4d-00163e2aabff.json HTTP/1.1\" 200 550 \"-\" \"Ruby\" \"-\" 0.009\n")
     assert !Kronk::Player::RequestParser.start_new?("foobar\r\n")
   end
 

data/test/test_response.rb

@@ -454,7 +454,7 @@ STR
     expected = JSON.parse \
       File.read("test/mocks/200_response.json").split("\r\n\r\n")[1]
 
-    expected = Kronk::Diff.ordered_data_string expected, true
+    expected = Kronk::DataString.new expected, :struct => true
 
     assert_equal expected, str
   end

data/test/test_transaction.rb

@@ -30,19 +30,35 @@ class TestTransaction < Test::Unit::TestCase
 
   def test_many_transactions
     data = @trans.run do |t|
-      t.map "key?"     => "thing%1",
-            "key3/*/0" => "key_value"
-      t.select "findme/0..1"
+      t.select "findme/0..1", "key(1|3)"
+      t.move [["key3/*/0", "key_value"], ["key?", "thing%1"]]
       t.delete "findme/0"
-      t.move "findme/2" => "last_thing"
+      t.move "findme/1" => "last_thing"
     end
 
     expected = {
-      "last_thing"=>{}, "key_value"=>"val1",
+      "last_thing"=>456 , "key_value"=>"val1", "findme" => [],
       "thing1"=>{:key1a=>["foo", "bar", "foobar", {:findme=>"thing"}],
         "key1b"=>"findme"},
-      "thing2"=>"foobar",
-      "thing3"=>{:key3a=>["val1", "val2", "val3"]}, "findme"=>[456]}
+      "thing3"=>{:key3a=>["val2", "val3"]}}
+
+    assert_equal expected, data
+  end
+
+
+  def test_many_transactions_with_map
+    data = @trans.run do |t|
+      t.select "findme/0..1", "key(1|3)"
+      t.map [["key3/*/0", "key_value"], ["key?", "thing%1"]]
+      t.delete "findme/0"
+      t.move "findme/1" => "last_thing"
+    end
+
+    expected = {
+      "key_value"=>"val1",
+      "thing1"=>{:key1a=>["foo", "bar", "foobar", {:findme=>"thing"}],
+        "key1b"=>"findme"},
+      "thing3"=>{:key3a=>["val2", "val3"]}}
 
     assert_equal expected, data
   end
@@ -64,7 +80,7 @@ class TestTransaction < Test::Unit::TestCase
 
   def test_run
     expected = {
-      :key1=>{:key1a=>["foo", "foobar", {}]},
+      :key1=>{:key1a=>["foo", "foobar"]},
       :key2=>"foobar",
       "findme"=>[123, 456, {:findme=>123456}]
     }
@@ -93,7 +109,7 @@ class TestTransaction < Test::Unit::TestCase
     result = @trans.results
 
     expected = {
-      :key1=>{:key1a=>["foo", "foobar", {}]},
+      :key1=>{:key1a=>["foo", "foobar"]},
       :key2=>"foobar",
       "findme"=>[123, 456, {:findme=>123456}]
     }
@@ -109,7 +125,7 @@ class TestTransaction < Test::Unit::TestCase
     result = @trans.results :keep_indicies => true
 
     expected = {
-      :key1=>{:key1a=>{2=>"foobar", 0=>"foo", 3=>{}}},
+      :key1=>{:key1a=>{2=>"foobar", 0=>"foo"}},
       :key2=>"foobar",
       "findme"=>[123, 456, {:findme=>123456}]
     }
@@ -324,10 +340,11 @@ class TestTransaction < Test::Unit::TestCase
       :key3=>{}, "findme"=>[123, 456, {}],
       "more"=>{"one-findme"=>"thing", "two-findme"=>123456}}
 
-    data = @trans.transaction_move @data, "key*/key??" => "mapped/%1-%3",
-                                          "mapped"     => "remapped",
-                                          "**=thing"   => "more/one-%1",
-                                          "**=123456"  => "more/two-%1"
+    data = @trans.transaction_move @data,
+              ["**=thing",   "more/one-%1"],
+              ["key*/key??", "mapped/%1-%3"],
+              ["mapped",     "remapped"],
+              ["**=123456",  "more/two-%1"]
     data = @trans.remake_arrays data
 
     assert_equal expected, data
@@ -338,14 +355,37 @@ class TestTransaction < Test::Unit::TestCase
   def test_transaction_map
     expected = {
       "mapped"=>{
-        "1-a"=>["foo", "bar", "foobar", {:findme=>"thing"}],
+        "1-a"=>["foo", "bar", "foobar", {}],
+        "1-b"=>"findme", "3-a"=>["val1", "val2", "val3"]},
+      "more"=>[{:findme=>"thing"}]
+    }
+
+    data = @trans.transaction_map @data,
+              ["**=thing",   "more/12/%1"],
+              ["key*/key??", "mapped/%1-%3"],
+              ["mapped",     "remapped"]
+
+    data = @trans.remake_arrays data
+
+    assert_equal expected, data
+    assert_not_equal @data, data
+  end
+
+
+  def test_transaction_map_no_target
+    expected = {
+      "mapped"=>{
+        "1-a"=>["foo", "bar", "foobar", {}],
         "1-b"=>"findme", "3-a"=>["val1", "val2", "val3"]},
-      "more"=>{:findme=>"thing"}
+      :key1=>{:key1a => [{:findme=>"thing"}]}
     }
 
-    data = @trans.transaction_map @data, "key*/key??" => "mapped/%1-%3",
-                                         "mapped"     => "remapped",
-                                         "**=thing"   => "more/%1"
+    data = @trans.transaction_map @data,
+              "**=thing",
+              ["key*/key??", "mapped/%1-%3"],
+              ["mapped",     "remapped"]
+
+    data = @trans.remake_arrays data
 
     assert_equal expected, data
     assert_not_equal @data, data
@@ -356,7 +396,7 @@ class TestTransaction < Test::Unit::TestCase
     expected = {:key1=>{:key1a=>[], "key1b"=>"findme"},:key2=>"foobar",
       :key3=>{:key3a=>[]}, "findme"=>[123, 456, {:findme=>123456}]}
 
-    data = @trans.transaction_move @data, "key*/key??/*" => "mapped/%4"
+    data = @trans.transaction_move @data, ["key*/key??/*", "mapped/%4"]
     data = @trans.remake_arrays data
 
     mapped = data.delete "mapped"
@@ -424,6 +464,14 @@ class TestTransaction < Test::Unit::TestCase
   end
 
 
+  def test_is_integer
+    assert @trans.is_integer?("123")
+    assert @trans.is_integer?(:"123")
+    assert !@trans.is_integer?("foo123")
+    assert !@trans.is_integer?(:foo123)
+  end
+
+
   def test_ary_to_hash
     expected = {1 => :a, 0 => :foo, 2 => :b}
     assert_equal expected, @trans.ary_to_hash([:foo, :a, :b])
@@ -441,30 +489,30 @@ class TestTransaction < Test::Unit::TestCase
 
     @trans.clear
 
-    assert @trans.instance_variable_get(:@actions)[:delete].empty?
-    assert @trans.instance_variable_get(:@actions)[:select].empty?
+    assert @trans.instance_variable_get(:@actions).empty?
     assert @trans.instance_variable_get(:@make_array).empty?
   end
 
 
   def test_select
     @trans.select "path1", "path2", "path3"
-    assert_equal ["path1", "path2", "path3"],
-                 @trans.instance_variable_get(:@actions)[:select]
+    assert_equal [[:select, ["path1", "path2", "path3"]]],
+                 @trans.instance_variable_get(:@actions)
 
     @trans.select "path4", "path5"
-    assert_equal ["path1", "path2", "path3", "path4", "path5"],
-                 @trans.instance_variable_get(:@actions)[:select]
+    assert_equal [[:select, ["path1", "path2", "path3", "path4", "path5"]]],
+                 @trans.instance_variable_get(:@actions)
   end
 
 
   def test_delete
     @trans.delete "path1", "path2", "path3"
-    assert_equal ["path1", "path2", "path3"],
-                 @trans.instance_variable_get(:@actions)[:delete]
+    assert_equal [[:delete, ["path1", "path2", "path3"]]],
+                 @trans.instance_variable_get(:@actions)
 
     @trans.delete "path4", "path5"
-    assert_equal ["path1", "path2", "path3", "path4", "path5"],
-                 @trans.instance_variable_get(:@actions)[:delete]
+    assert_equal [[:delete, ["path1", "path2", "path3"]],
+                  [:delete, ["path4", "path5"]]],
+                 @trans.instance_variable_get(:@actions)
   end
 end