kronk 1.7.8 → 1.8.0

data/lib/kronk/test/helper_methods.rb

@@ -58,7 +58,7 @@ class Kronk
         @response  = @kronk.response
         @datas     = @responses.map do |r|
                        begin
-                         r.selective_data options
+                         r.data options
                        rescue Kronk::Response::MissingParser
                          r.body
                        end

data/test/test_assertions.rb

@@ -81,7 +81,7 @@ class TestAssertions < Test::Unit::TestCase
     Kronk.expects(:request).
       with("host2.com", :foo => "bar").returns mock_resp2
 
-    left  = Kronk::DataString.new mock_resp1.selective_data
+    left  = Kronk::DataString.new mock_resp1.data
     right = mock_resp2.body
 
     assert_not_equal left, right

data/test/test_cmd.rb

@@ -274,15 +274,15 @@ class TestCmd < Test::Unit::TestCase
     opts = Kronk::Cmd.parse_args %w{uri -c 2 -n 100 -o}
     assert_equal 2,   opts[:player].concurrency
     assert_equal 100, opts[:player].number
-    assert_equal Kronk::Player::Stream, opts[:player].output.class
+    assert_equal Kronk::Player::Stream, opts[:player].class
 
     opts = Kronk::Cmd.parse_args %w{uri -o benchmark}
-    assert_equal Kronk::Player::Benchmark, opts[:player].output.class
+    assert_equal Kronk::Player::Benchmark, opts[:player].class
   end
 
 
   def test_parse_args_player_stdin
-    $stdin.expects(:tty?).returns(false).times(6)
+    $stdin.expects(:tty?).returns(false).times(7)
 
     opts = Kronk::Cmd.parse_args %w{uri -p}
     assert_equal $stdin, opts[:player].input.io
@@ -291,12 +291,12 @@ class TestCmd < Test::Unit::TestCase
     opts = Kronk::Cmd.parse_args %w{uri --benchmark}
     assert_equal $stdin, opts[:player].input.io
     assert_equal %w{uri}, opts[:uris]
-    assert_equal Kronk::Player::Benchmark, opts[:player].output.class
+    assert_equal Kronk::Player::Benchmark, opts[:player].class
 
     opts = Kronk::Cmd.parse_args %w{uri --stream}
     assert_equal $stdin, opts[:player].input.io
     assert_equal %w{uri}, opts[:uris]
-    assert_equal Kronk::Player::Stream, opts[:player].output.class
+    assert_equal Kronk::Player::Stream, opts[:player].class
   end
 
 
@@ -309,11 +309,11 @@ class TestCmd < Test::Unit::TestCase
 
     opts = Kronk::Cmd.parse_args %w{uri --benchmark mock_file}
     assert_equal mock_file, opts[:player].input.io
-    assert_equal Kronk::Player::Benchmark, opts[:player].output.class
+    assert_equal Kronk::Player::Benchmark, opts[:player].class
 
     opts = Kronk::Cmd.parse_args %w{uri --stream mock_file}
     assert_equal mock_file, opts[:player].input.io
-    assert_equal Kronk::Player::Stream, opts[:player].output.class
+    assert_equal Kronk::Player::Stream, opts[:player].class
   end
 
 
@@ -399,13 +399,20 @@ class TestCmd < Test::Unit::TestCase
 
   def test_parse_args_uris_with_io
     $stdin.expects(:tty?).returns(false)
-    $stdin.expects(:read).returns("MOCK RESPONSE")
+
+    if "1.9".respond_to?(:encoding)
+      $stdin.stubs(:read_nonblock).raises(EOFError)
+      $stdin.expects(:read_nonblock).returns("MOCK RESPONSE")
+    else
+      $stdin.stubs(:sysread).raises(EOFError)
+      $stdin.expects(:sysread).returns("MOCK RESPONSE")
+    end
 
     opts = Kronk::Cmd.parse_args %w{uri1 uri2}
     assert_equal 2, opts[:uris].length
     assert_equal "uri1", opts[:uris][1]
-    assert_equal StringIO, opts[:uris][0].class
-    assert_equal "MOCK RESPONSE", opts[:uris][0].read
+    assert_equal Kronk::BufferedIO, opts[:uris][0].class
+    assert_equal "MOCK RESPONSE", opts[:uris][0].read_all
   end
 
 
@@ -490,7 +497,7 @@ class TestCmd < Test::Unit::TestCase
 
   def test_run_caught_errors
     errs = {
-      Kronk::Exception               => "Kronk::Exception",
+      Kronk::Error                   => "Kronk::Error",
       Kronk::Response::MissingParser => "Kronk::Response::MissingParser",
       Errno::ECONNRESET              => "Connection reset by peer"
     }

data/test/test_diff.rb

@@ -225,6 +225,45 @@ class TestDiff < Test::Unit::TestCase
   end
 
 
+  def test_create_diff_duplicate_match_middle
+    str1 = "line2\nline3a\nline3\nline4\nline5\nline6\nline4\nline6\nline7"
+    str2 = "line2\nline3\nline4\nline5\nline6\nline7"
+
+    expected = [
+      "line2",
+      [["line3a"], []],
+      "line3",
+      "line4",
+      "line5",
+      "line6",
+      [["line4", "line6"], []],
+      "line7"
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
+  def test_create_diff_duplicate_match_start
+    str1 = "line2\nline5\nline6\nline7\nline8\nline9"
+    str2 = "line2\nline5\nline6\nline7\nline5\nline6\nline7\nline8\nline9"
+
+    expected = [
+      "line2",
+      [[], ["line5", "line6", "line7"]],
+      "line5",
+      "line6",
+      "line7",
+      "line8",
+      "line9"
+    ]
+
+    diff = Kronk::Diff.new str1, str2
+    assert_equal expected, diff.create_diff
+  end
+
+
   def test_count
     assert_equal 4, @diff.count
   end

data/test/test_helper.rb

@@ -1,6 +1,6 @@
 require "test/unit"
-require "kronk/async"
 require "mocha"
+require "kronk"
 
 Kronk.config[:context] = nil
 
@@ -148,18 +148,26 @@ ensure
 end
 
 
+def with_buffer_size size
+  old_size = Net::BufferedIO::BUFSIZE
+  Net::BufferedIO.send :remove_const, :BUFSIZE
+  Net::BufferedIO.const_set :BUFSIZE, size
+  yield
+ensure
+  Net::BufferedIO.send :remove_const, :BUFSIZE
+  Net::BufferedIO.const_set :BUFSIZE, old_size
+end
+
+
 def expect_request req_method, url, options={}
   uri  = URI.parse url
 
   resp = Kronk::Response.new(options[:returns] || mock_200_response)
   resp.stubs(:code).returns(options[:status] || '200')
+  resp.stubs(:to_hash).returns Hash.new
 
   http   = mock 'http'
-  socket = mock 'socket'
   req    = mock 'req'
-  res    = mock 'res'
-
-  res.stubs(:to_hash).returns Hash.new
 
   data   = options[:data]
   data &&= Hash === data ? Kronk::Request.build_query(data) : data.to_s
@@ -167,20 +175,16 @@ def expect_request req_method, url, options={}
   headers = options[:headers] || Hash.new
   headers['User-Agent'] ||= Kronk::DEFAULT_USER_AGENT
 
-  req.expects(:start).yields(http).returns res
-
-  http.expects(:instance_variable_get).with("@socket").returns socket
-
-  socket.expects(:debug_output=)
+  req.expects(:start).yields(http).returns resp
 
   Kronk::Request::VanillaRequest.expects(:new).
     with(req_method.to_s.upcase, uri.request_uri, headers).returns req
 
-  Net::HTTP.expects(:new).with(uri.host, uri.port).returns req
-
-  http.expects(:request).with(req, data).returns res
+  Kronk::HTTP.expects(:new).with(uri.host, uri.port).returns req
 
-  Kronk::Response.expects(:new).returns resp
+  http.expects(:request).
+    with(req, data, has_entry(:request => instance_of(Kronk::Request))).
+    returns resp
 
   yield http, req, resp if block_given?
 

data/test/test_helper_methods.rb

@@ -13,7 +13,8 @@ class TestHelperMethods < Test::Unit::TestCase
     @mock_req   = stub("mock_req", :retrieve => @mock_resp,  :uri => "host.com")
     @mock_req2  = stub("mock_req", :retrieve => @mock_resp2, :uri => "host.com")
 
-    @mock_thread = stub("mock_thread", :join => nil)
+    @mock_thread = stub("mock_thread", :join => true,
+                         :abort_on_exception= => true)
 
     Thread.stubs(:new).yields.returns @mock_thread
     Kronk::Request.any_instance.stubs(:new).returns @mock_req
@@ -97,7 +98,7 @@ class TestHelperMethods < Test::Unit::TestCase
     Kronk::Request.expects(:new).
       with("host.com", :foo => "bar", :test => "thing").returns @mock_req
 
-    @mock_resp.expects(:selective_data).with(:foo => "bar", :test => "thing").
+    @mock_resp.expects(:data).with(:foo => "bar", :test => "thing").
       returns @json
 
     retrieve "host.com", {:foo => "bar"}, :test => "thing"
@@ -119,8 +120,8 @@ class TestHelperMethods < Test::Unit::TestCase
     Kronk::Request.expects(:new).
       with("host2.com", :foo => "bar").returns @mock_req2
 
-    @mock_resp.expects(:selective_data).twice.with(:foo => "bar").returns @json
-    @mock_resp2.expects(:selective_data).twice.with(:foo => "bar").returns @json
+    @mock_resp.expects(:data).twice.with(:foo => "bar").returns @json
+    @mock_resp2.expects(:data).twice.with(:foo => "bar").returns @json
 
     retrieve "host1.com", "host2.com", :foo => "bar"
 

data/test/test_kronk.rb

@@ -4,7 +4,6 @@ class TestKronk < Test::Unit::TestCase
 
   def test_default_config
     expected = {
-      :async         => 'auto',
       :content_types => {
         'js'      => 'JSON',
         'json'    => 'JSON',
@@ -34,7 +33,6 @@ class TestKronk < Test::Unit::TestCase
   def test_load_config
     with_config do
       mock_config = {
-        :async         => false,
         :content_types => {
           'soap' => "SOAPParser",
           'js'   => "JsEngine"
@@ -64,7 +62,6 @@ class TestKronk < Test::Unit::TestCase
       Kronk.load_config "foobar"
 
       expected = {
-        :async         => false,
         :content_types => {
           'soap'  => "SOAPParser",
           'js'    => "JsEngine",
@@ -374,8 +371,8 @@ class TestKronk < Test::Unit::TestCase
                              :show_headers => true,
                              :raw => true
 
-    exp_diff = Kronk::Diff.new resp1.selective_string(:show_headers => true),
-                               resp2.selective_string(:show_headers => true),
+    exp_diff = Kronk::Diff.new resp1.to_s,
+                               resp2.to_s,
                                :labels => [
                                  "test/mocks/200_response.json",
                                  "test/mocks/200_response.xml"
@@ -453,8 +450,8 @@ class TestKronk < Test::Unit::TestCase
                              :show_headers => true
 
     exp_diff = Kronk::Diff.new_from_data \
-                  resp1.selective_data(:show_headers => true),
-                  resp2.selective_data(:show_headers => true),
+                  resp1.data(:show_headers => true),
+                  resp2.data(:show_headers => true),
                   :labels => [
                     "test/mocks/200_response.json",
                     "test/mocks/200_response.xml"
@@ -502,7 +499,7 @@ class TestKronk < Test::Unit::TestCase
   def test_follow_redirect_no_redirect
     res = Kronk::Response.new mock_200_response
     req = Kronk::Request.new "http://www.google.com/"
-    req.stubs(:request).returns res
+    req.stubs(:retrieve).returns res
 
     Kronk::Request.expects(:new).with("http://www.google.com/",{}).never
     Kronk::Request.expects(:new).
@@ -515,7 +512,7 @@ class TestKronk < Test::Unit::TestCase
   def test_do_not_follow_redirect
     res = Kronk::Response.new mock_302_response
     req = Kronk::Request.new "http://www.google.com/"
-    req.stubs(:request).returns res
+    req.stubs(:retrieve).returns res
 
     Kronk::Request.expects(:new).with("http://www.google.com/",{}).never
     Kronk::Request.expects(:new).
@@ -548,8 +545,8 @@ class TestKronk < Test::Unit::TestCase
     assert_equal nil,           kronk.diff
 
     exp_diff = Kronk::Diff.new_from_data \
-                  resp2.selective_data(:show_headers => true),
-                  resp1.selective_data(:show_headers => true),
+                  resp2.data(:show_headers => true),
+                  resp1.data(:show_headers => true),
                   :labels => [
                     "test/mocks/200_response.json",
                     "test/mocks/200_response.xml"

data/test/test_player.rb

@@ -4,19 +4,22 @@ class TestPlayer < Test::Unit::TestCase
 
   class MockPipe < StringIO; end
 
-  class MockOutput < Kronk::Player::Output
+  class MockPlayer < Kronk::Player
     attr_accessor :result_calls
 
-    def initialize *args
+    def start
       @result_calls = 0
-      super
     end
 
-    def result kronk, mutex
-      mutex.synchronize do
+    def result kronk
+      @mutex.synchronize do
         @result_calls += 1
       end
     end
+
+    def interrupt
+      raise "Interrupted"
+    end
   end
 
   class MockParser
@@ -27,20 +30,18 @@ class TestPlayer < Test::Unit::TestCase
 
 
   def setup
-    Kronk::Player.async = false
-
     @io        = MockPipe.new
     @parser    = MockParser
-    @output    = MockOutput
-    @player    = Kronk::Player.new :io     => @io,
-                                   :parser => @parser,
-                                   :output => @output
+    @player    = MockPlayer.new :io     => @io,
+                                :parser => @parser
+
+    @player.on(:result){|(kronk, err)| @player.trigger_result(kronk, err) }
   end
 
 
   def test_init_defaults
-    player = Kronk::Player.new
-    assert_equal Kronk::Player::Suite,       player.output.class
+    player = Kronk::Player.new_type 'suite'
+    assert_equal Kronk::Player::Suite,       player.class
     assert_equal Kronk::Player::InputReader, player.input.class
     assert_equal Mutex,                      player.mutex.class
     assert_equal 1,                          player.concurrency
@@ -63,29 +64,30 @@ class TestPlayer < Test::Unit::TestCase
 
 
   def test_init_opts
-    player = Kronk::Player.new :number      => 1000,
-                               :concurrency => 10,
-                               :output      => :stream
+    player = Kronk::Player.new_type :stream,
+                                    :number      => 1000,
+                                    :concurrency => 10
 
-    assert_equal Kronk::Player::Stream,        player.output.class
+    assert_equal Kronk::Player::Stream,        player.class
     assert_equal Kronk::Player::RequestParser, player.input.parser
     assert_equal 10,                           player.concurrency
     assert_equal 1000,                         player.number
   end
 
 
-  def test_output
-    @player.output_from :benchmark
-    assert_equal Kronk::Player::Benchmark, @player.output.class
+  def test_new_type
+    @player = Kronk::Player.new_type :benchmark
+    assert_equal Kronk::Player::Benchmark, @player.class
 
-    @player.output_from :stream
-    assert_equal Kronk::Player::Stream, @player.output.class
+    @player = Kronk::Player.new_type :stream
+    assert_equal Kronk::Player::Stream, @player.class
 
-    @player.output_from :suite
-    assert_equal Kronk::Player::Suite, @player.output.class
+    @player = Kronk::Player.new_type :suite
+    assert_equal Kronk::Player::Suite, @player.class
 
-    @player.output_from Kronk::Player::Benchmark
-    assert_equal Kronk::Player::Benchmark, @player.output.class
+    assert_raises NameError do
+      @player = Kronk::Player.new_type :foo
+    end
   end
 
 
@@ -164,10 +166,6 @@ 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"
     @player.input.io.rewind
@@ -192,7 +190,7 @@ class TestPlayer < Test::Unit::TestCase
 
     @player.compare "example.com", "beta-example.com", :query => "foo=bar"
 
-    assert_equal 5, @player.output.result_calls
+    assert_equal 5, @player.result_calls
   end
 
 
@@ -243,9 +241,7 @@ class TestPlayer < Test::Unit::TestCase
 
   def test_run_interrupted
     @player.concurrency = 0
-
-    @player.output.expects :start
-    @player.output.expects :completed
+    @player.instance_eval "undef interrupt"
 
     thread = Thread.new do
       @player.run do |item, mutex|
@@ -263,8 +259,7 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_process_queue
-    @player.concurrency = 10
+  def test_concurrently
     requests = (1..20).map{|n| "request #{n}"}
     @player.queue.concat requests.dup
     @player.input.io.close
@@ -272,7 +267,7 @@ class TestPlayer < Test::Unit::TestCase
     start     = Time.now
     processed = []
 
-    @player.process_queue do |req|
+    @player.concurrently 10 do |req|
       processed << req
       sleep 0.5
     end
@@ -287,8 +282,7 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_process_queue_from_io
-    @player.concurrency = 10
+  def test_concurrently_from_io
     @player.input.parser.stubs(:start_new?).returns true
     @player.input.parser.stubs(:start_new?).with("").returns false
 
@@ -300,7 +294,7 @@ class TestPlayer < Test::Unit::TestCase
     @player.from_io StringIO.new(requests.join)
 
     start_time = Time.now
-    @player.process_queue do |req|
+    @player.concurrently 10 do |req|
       processed << req
       sleep 0.5
     end
@@ -348,10 +342,9 @@ class TestPlayer < Test::Unit::TestCase
   def test_start_input_from_input
     @player.input.stubs(:get_next).returns "mock_request"
 
-    @player.concurrency = 5
-    @player.number      = 20
+    @player.number = 30
 
-    thread = @player.start_input!
+    thread = @player.start_input! 10
     assert_equal Thread, thread.class
 
     sleep 0.2
@@ -371,10 +364,9 @@ class TestPlayer < Test::Unit::TestCase
     @player.input.stubs(:get_next).returns nil
     @player.input.stubs(:eof?).returns false
 
-    @player.concurrency = 5
     @player.queue << "mock_request"
 
-    thread = @player.start_input!
+    thread = @player.start_input! 10
     assert_equal Thread, thread.class
 
     sleep 0.2
@@ -427,11 +419,7 @@ class TestPlayer < Test::Unit::TestCase
   end
 
 
-  def test_process_compare_one
-    mock_thread = "mock_thread"
-    Thread.expects(:new).twice.yields.returns mock_thread
-    mock_thread.expects(:join).twice
-
+  def test_run
     resp1 = Kronk::Response.new mock_resp("200_response.json")
     resp1.parser = JSON
     resp2 = Kronk::Response.new mock_resp("200_response.txt")
@@ -447,112 +435,68 @@ class TestPlayer < Test::Unit::TestCase
 
     @got_results = nil
 
-    @player.output.expects(:result).with do |kronk, mutex|
+    @player.expects(:result).with do |kronk|
       @got_results = true
-      assert_equal @player.mutex, mutex
       assert_equal Kronk::Diff.new(resp1.stringify, resp2.stringify).formatted,
                     kronk.diff.formatted
       true
     end
 
     opts = {:uri_suffix => "/test", :include_headers => true}
-    @player.process_one opts, :compare, "example.com", "beta-example.com"
+    @player.number = 1
+    @player.concurrency = 1
+    @player.queue << opts
+
+    @player.run do |kronk|
+      kronk.compare "example.com", "beta-example.com"
+    end
 
-    assert @got_results, "Expected output to get results but didn't"
+    assert @got_results, "Expected player to get results but didn't"
   end
 
 
-  def test_process_one_compare_error
+  def test_run_error
     @got_results = []
+    @player.number = 1
+    @player.concurrency = 1
 
-    @player.output.expects(:error).times(3).with do |error, kronk, mutex|
+    @player.expects(:error).times(3).with do |error, kronk|
       @got_results << error.class
-      assert_equal @player.mutex, mutex
-      assert_equal Kronk,         kronk.class
+      assert_equal Kronk, kronk.class
       true
     end
 
-    errs = [Kronk::Exception, Kronk::Response::MissingParser, Errno::ECONNRESET]
+    errs = [Kronk::Error, Kronk::Response::MissingParser, Errno::ECONNRESET]
     errs.each do |eklass|
       Kronk.any_instance.expects(:compare).
         with("example.com", "beta-example.com").
         raises eklass
 
       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_one_compare_error_not_caught
-    Kronk.any_instance.expects(:compare).
-      with("example.com", "beta-example.com").
-      raises RuntimeError
-
-    assert_raises RuntimeError do
-      opts = {:uri_suffix => "/test", :include_headers => true}
-      @player.process_one opts, :compare, "example.com", "beta-example.com"
-    end
-  end
-
 
-  def test_process_one_request
-    resp = Kronk::Response.new mock_resp("200_response.json")
-    resp.parser = JSON
-
-    req = Kronk::Request.new "example.com"
-    req.expects(:retrieve).returns resp
-
-    Kronk::Request.expects(:new).returns req
-
-    @got_results = nil
-
-    @player.output.expects(:result).with do |kronk, mutex|
-      @got_results = true
-      assert_equal @player.mutex, mutex
-      assert_equal resp, kronk.response
-      true
+      @player.run opts do |kronk|
+        kronk.compare "example.com", "beta-example.com"
+      end
     end
 
-    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"
+    assert_equal errs, @got_results, "Expected player to get errors but didn't"
   end
 
 
-  def test_process_one_request_error
-    @got_results = []
-
-    @player.output.expects(:error).times(3).with do |error, kronk, mutex|
-      @got_results << error.class
-      assert_equal @player.mutex, mutex
-      assert_equal Kronk,         kronk.class
-      true
-    end
+  def test_run_error_not_caught
+    @player.number = 1
+    @player.concurrency = 1
 
-    errs = [Kronk::Exception, Kronk::Response::MissingParser, Errno::ECONNRESET]
-    errs.each do |eklass|
-      Kronk.any_instance.expects(:request).with("example.com").
-        raises eklass
+    Kronk.any_instance.expects(:compare).
+      with("example.com", "beta-example.com").
+      raises ArgumentError
 
+    assert_raises ArgumentError do
       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_one_request_error_not_caught
-    Kronk.any_instance.expects(:request).with("example.com").
-      raises RuntimeError
-
-    assert_raises RuntimeError do
-      opts = {:uri_suffix => "/test", :include_headers => true}
-      @player.process_one opts, :request, "example.com"
+      @player.run opts do |kronk|
+        kronk.compare "example.com", "beta-example.com"
+      end
     end
   end