rwb 0.2.1

data/NEWS

@@ -0,0 +1,29 @@
+version 0.2.1
+  +  added quartile graphs by url or overall
+  +  added more information to response objects
+  +  released as a gem w00t!
+
+Version 0.2.0
+  +  added proxy handling throughout
+
+Version 0.1.1
+Changes in this version:
+  +  added three kinds of warmup methods
+
+Version 0.1.0
+Changes in this version:
+  +  starting to add documentation
+  +  added more granular control over reporting levels
+  +  fixed standard deviation
+
+
+Version 0.0.1
+Changes in this version:
+  +  made reporting more modular
+  +  added reporting based on slices of the results
+  +  added standard deviation for mean time per request
+  +  fixed standard deviation
+
+Version 0.0.0
+Changes in this version:
+  +  Initial Release

data/README

@@ -0,0 +1,75 @@
+RWB, the Ruby Web Bench, provides a simple way to manage a performance and
+load tests suite for your webserver.  Unlike ab, by which it was inspired, it
+will allow you to build a collection of test URLs with corresponding weights
+which it will use to generate the actual tests that it runs (and reports on).
+
+RWB could be used for:
+ - testing your website to ensure that it performs within timing
+   requirements 
+ - testing a new webserver to verify that performance is at least as good
+   as your existing server
+ - testing a website to verify that it will handle expected load
+
+While this is an alpha release, it is already useful.  The API is expected to
+change somewhat as functionality is added and the design is adjusted.
+Reporting by error type, serializing of results, cookie handling, POST
+requests, and set_up methods are some of the planned additions before rwb
+hits a beta release.
+
+A sample RWB script for testing a website looks like this (for more
+information, see the file USING):
+
+#!/usr/bin/env ruby
+
+require 'rwb'
+
+urls = RWB::Builder.new()
+
+urls.add_url(10, "http://www.example.com")
+urls.add_url(10, "http://www.example.com/nonesuch")
+urls.add_url(70, "http://www.example.com/entries")
+
+queries = ['foo+bar', 'bar+baz', 'quux']
+urls.add_url_group(10, "http://www.example.com:3000/search?", queries)
+
+tests = RWB::Runner.new(urls, 100, 20)
+tests.report_header
+tests.report_overall
+tests.graph_quartiles_urls(1000)
+
+
+
+The output from this script looks like this:
+$ ruby -Ilib quick.rb
+completed 10 runs
+completed 20 runs
+completed 30 runs
+completed 40 runs
+completed 50 runs
+completed 60 runs
+completed 70 runs
+completed 80 runs
+completed 90 runs
+completed 100 runs
+Concurrency Level:       20
+Total Requests:          100
+Total time for testing:  2.021048 secs
+Requests per second:     49.4792800566835
+Mean time per request:   236  msecs
+Standard deviation:      342
+Overall results:
+        Shortest time:  30 msecs
+        25.0%ile time:  74 msecs
+        50.0%ile time:  98 msecs
+        75.0%ile time:  185 msecs
+        Longest time:   1281 msecs
+http://localhost:
+        0:  +-|                                           :1000
+http://localhost/nonesuch:
+        0: [|+----|                                       :1000
+http://localhost/entries:
+        0:[ |+--|                                         :1000
+http://localhost:3000/search?:
+        0:  |------+--------------------------------------:1000
+
+(Additional examples of use can be seen at www.red-bean.com/~pate/

data/TODO

@@ -0,0 +1,15 @@
+Enhance docs & tests  (in progress)
+
+Figure out and implement cookie handling
+
+Add POST capabilities
+
+Enhance reporting to use expanded info in Response Objects  (in progress)
+
+Migrate to a DSL
+
+(maybe) Add html output
+
+(maybe) Add PDF output
+
+

data/lib/rwb.rb

@@ -0,0 +1,493 @@
+require 'net/http'
+require 'uri'
+
+module RWB
+
+  #
+  # The Url class holds individual URLs for testing.  +Url+s are defined by a 
+  # Fixnum representing the weight and a String representing the URL itself.
+  # The weights are not required to be percentages.
+  #
+  #   url = RWB::Url.new(20, "http://www.example.com")
+  class Url
+    attr_reader :weight
+
+    def initialize(weight, url)
+      @weight = weight
+      @url = url
+    end
+    
+    # to_url returns the URL to be requested as a string
+    #
+    #   url.to_url  # => "http://www.example.com" 
+    def to_url
+      @url
+    end
+
+    #
+    # to_base returns a string suitable for creating a +Regexp+ to match
+    # against. 
+    # 
+    #   url.to_base # => "http://www.example.com "
+    #  
+    def to_base
+      @url
+    end
+
+    def to_s
+      @weight + " " + @url
+    end
+  end
+
+  #
+  # A UrlGroup is a collection of related URLs, for example the URL for a
+  # search tool, with several search queries.   The group is weighted (and
+  # reported on) as a whole, but individual requests are made with random
+  # elements from an array of extensions.
+  #
+  #   urls = UrlGroup.new(20, "http://www.example.com/search?",
+  #           ["foo", "bar", "baz"])
+  #
+  class UrlGroup
+    attr_reader :weight
+
+    def initialize(weight, base, extension_array)
+      @weight = weight.to_i
+      @base = base.to_s
+      @extension_array = extension_array
+    end
+
+    #
+    # to_url returns a complete URL to be requested.  It takes an optional
+    # seed argument, which must be a Fixnum.  If given, this will seed the
+    # random selection of the extension.
+    #
+    #   urls.to_url(1234)  # => "http://www.example.com/search?baz"
+    #
+    def to_url(seed = nil)
+      if seed
+        srand = seed
+      end
+      @base + @extension_array[rand(@extension_array.length)]
+    end
+
+    #
+    # to_base returns a String suitable for building a Regex to match
+    # against.  This String will not include any extensions.
+    #
+    #   urls.to_base  # => "http://www.example.com/search?"
+    #
+    def to_base
+      @base
+    end
+
+    def to_s
+      @weight + " " + @base
+    end
+
+  end
+
+  class Result
+    attr_reader :id, :timestamp, :url
+    attr_reader :elapsed_time, :response_code
+
+    def initialize(id, timestamp, url, elapsed_time, response_code)
+      @id = id
+      @timestamp = timestamp
+      @url = url
+      @elapsed_time = elapsed_time
+      @response_code = response_code
+    end
+  end
+
+  class RunResults
+    attr_reader :results
+
+    def initialize
+      @results = Array.new
+    end
+ 
+    def add_result(result)
+      @results.push(result)
+    end
+
+    def each_by_response_code(code)
+      @results.each do |result|
+        yield result if result.response_code.to_i == code.to_i
+      end
+    end
+
+    def all_by_response_code(code)
+      coded_results = Array.new
+      @results.each do |result|
+        if result.response_code.to_i == code.to_i
+          coded_results.push(result)
+        end
+      end
+      coded_results
+    end
+
+    def all_by_url(url)
+      coded_results = Array.new
+      @results.each do |result|
+        if result.url.to_s == url.to_s
+          coded_results.push(result)
+        end
+      end
+      coded_results
+    end
+
+    def each_by_url(url)
+      @results.each do |result|
+        yield result if result.url.to_s == url.to_s
+      end
+    end
+
+    def all_with_id
+      id_results = Hash.new
+      @results.each do |result|
+        id_results[result.id] = result
+      end
+      id_results
+    end
+
+    def times_by_url(url =  nil)
+      coded_results = Array.new
+      @results.each do |result|
+        if url
+          if result.url.to_s == url.to_s
+            coded_results.push(result.elapsed_time)
+          end
+        else
+            coded_results.push(result.elapsed_time)
+        end          
+      end
+      coded_results
+    end
+
+  end
+
+  class Builder
+    attr_reader :urls, :total_weight
+
+    def initialize(testhash = nil)
+      @urls = Hash.new
+      @total_weight = 0
+      if testhash
+        build_urls(testhash)
+      end
+    end
+
+    def add_url(weight, url)
+      @total_weight += weight.to_i
+      @urls[@total_weight] = Url.new(weight, url)
+    end
+
+    def add_url_group(weight, base, extension_array)
+      @total_weight += weight.to_i
+      @urls[@total_weight] = UrlGroup.new(weight, base, extension_array)
+    end
+
+    def get_url(seed = nil)
+      if seed
+        srand seed
+      end
+      pick = rand(@total_weight)
+      @urls.keys.sort.each do |key|
+        if pick <= key
+          return @urls[key]
+        end
+      end
+    end
+    
+    def build_urls(tests)
+      tests.keys.each do |key|
+        add_url(tests[key], key)
+      end
+    end
+  end
+
+  class Runner
+    attr_accessor :sla_levels
+
+    def initialize(urls, max_runs=100, max_threads=10)
+      @urls = urls
+      @current_runs = 0
+      @current_threads = 0
+      @max_runs = max_runs
+      @max_threads = max_threads
+      @threads = []
+      @results_mean = nil
+      @results_std_dev = nil
+      @sla_levels = [0.5, 0.9]
+      @http = Net::HTTP
+      @new_results = RunResults.new
+    end
+    
+    def add_proxy(proxy_addr, proxy_port = 80, proxy_user = nil, 
+                  proxy_pass = nil)
+      @http = Net::HTTP::Proxy(proxy_addr, proxy_port, proxy_user,
+                               proxy_pass)
+    end
+
+    def warmup(num_runs = 1)
+      $stderr.puts "warming up with #{num_runs} runs"
+      for run in 1..num_runs
+        $stderr.print "#{run} "
+        @urls.urls.values.each do |url|
+          url = URI.parse(url.to_url)
+          @http.start(url.host, url.port) do |http|
+            http.request( Net::HTTP::Get.new(url) )
+          end
+        end
+      end
+      $stderr.puts
+    end
+
+    def rand_warmup(num_requests)
+      $stderr.puts "warming up with #{num_requests} requests"
+      checkpoint = num_requests/10
+      for run in 1..num_requests
+        if run % checkpoint == 0
+          $stderr.print "#{run} "
+        end
+        url = URI.parse(@urls.get_url.to_url)
+        @http.start(url.host, url.port) do |http|
+          http.request( Net::HTTP::Get.new(url) )
+        end
+      end
+      $stderr.puts
+    end
+
+    def spec_warmup(urls, num_runs=1)
+      $stderr.puts "warming up with #{num_runs} runs"
+      for run in 1..num_runs
+        $stderr.print "#{run} "
+        urls.each do |url|
+          url = URI.parse(url)
+          @http.start(url.host, url.port) do |http|
+            http.request( Net::HTTP::Get.new(url) )
+          end
+        end
+      end
+      $stderr.puts
+    end
+
+    def run
+      printed_runs = Array.new
+      total_start_time = Time.now
+      checkpoint = @max_runs/10
+      while @current_runs < @max_runs
+        build_thread
+        if @current_runs % checkpoint == 0 && 
+            ! ( printed_runs.include?(@current_runs))
+          $stderr.puts "completed #{@current_runs} runs"
+          printed_runs.push(@current_runs)
+        end
+      end
+      
+      @threads.each { |th| th.join }
+      
+      total_stop_time = Time.now
+      @total_time = total_stop_time - total_start_time
+    end
+
+    def results_mean
+      if @results_mean
+        return @results_mean
+      end
+      @results_mean = @new_results.times_by_url.inject(0) do |sum, time|
+        sum += time
+      end
+      @results_mean = @results_mean/@new_results.times_by_url.length
+      make_milli(@results_mean)
+    end
+
+    def results_std_dev
+      if @results_std_dev
+        return @results_std_dev
+      end
+      unless @results_mean
+        results_mean
+      end
+      @results_std_dev = @new_results.times_by_url.inject(0) do |std_dev, time|
+        std_dev += (time - @results_mean) ** 2
+      end
+      @results_std_dev = 
+        Math.sqrt(@results_std_dev/@new_results.times_by_url.length)
+      make_milli(@results_std_dev)
+    end
+
+    def adjust_scale(scale, max)
+      if scale/2 > max
+        scale = scale/2
+        scale = adjust_scale(scale, max)
+      end
+      scale
+    end
+
+    def results_quartile(times, scale = nil)
+      times = times.map { |t| make_milli(t) }
+      size = results_mean + results_std_dev * 2
+      min = times[0]
+      first  = times[(times.length*0.25).to_int - 1]
+      second = times[(times.length*0.5).to_int - 1]
+      third  = times[(times.length*0.75).to_int - 1]
+      max = times[-1]
+      
+      len = max.to_s.length
+      unless scale
+        scale = (max/((10**len).to_f)).ceil * (10**len)
+        scale = adjust_scale(scale, max)
+      end
+      step = scale/50
+      step = 1 if step == 0
+      scale = 50 if scale < 50
+      line = Array.new
+      char = ' '
+      for i in 0..49 do
+        case i
+        when max/step
+          line[i] = ']'
+        when third/step
+          line[i] = '|'
+          char = ' '
+        when second/step
+          line[i] = '+'
+        when first/step
+          line[i] = '|'
+          char = '-'
+        when min/step
+          line[i] = '['
+        when 0
+          line[i] = ':'
+        when 49
+          line[i] = ':'
+        else
+          line[i] = char
+        end
+      end
+      return '0' + line.join('')  + scale.to_s
+    end
+
+    def report_full(sla_levels = @sla_levels)
+      report_header
+      report_overall(sla_levels)
+      report_urls(sla_levels)
+      report_by_time(sla_levels)
+    end
+
+    def report_overall(sla_levels = @sla_levels)
+      results = @new_results.times_by_url
+      
+      puts "Overall results:"
+      print_times(results.sort, sla_levels)
+    end
+
+    def report_urls(sla_levels = @sla_levels)
+      @urls.urls.keys.sort.each do |key|
+        url = @urls.urls[key].to_base
+        results = @new_results.times_by_url(url)
+        puts "Results for #{url}:"
+        if results.length > 0
+          print_times(results.sort, sla_levels)
+        else
+          puts "no results for url"
+        end
+      end
+    end
+
+    def graph_quartiles_urls(scale = nil)
+      @urls.urls.keys.sort.each do |key|
+        url = @urls.urls[key].to_base
+        results = @new_results.times_by_url(url)
+        puts "#{url}:\n\t" + results_quartile(results.sort, scale)
+      end
+    end
+
+    def graph_quartiles_overall
+      results = @new_results.times_by_url
+      puts results_quartile(results.sort)
+    end
+
+    def report_by_time(sla_levels = @sla_levels, granularity = 0.2)
+      start = 0.0
+      stop = granularity
+      results = @new_results.times_by_url
+      puts "Results by time:"
+      while stop <= 1.0
+        first = (results.length * start).to_i
+        last = (results.length * stop).to_i
+        these_results = results.slice(first..last)
+        puts "results for requests #{first} - #{last}"
+        print_times(these_results.sort, sla_levels)
+        start = stop
+        stop += granularity
+      end
+    end
+
+    def print_times(results, levels)
+      times = get_times(results, levels)
+      puts  "\tShortest time:\t#{times.shift} msecs"
+      levels.each_with_index do |num, index|
+        percent = num.to_f * 100.0
+        puts "\t#{percent}%ile time:\t#{times[index]} msecs"
+      end
+      puts  "\tLongest time:\t#{times[-1]} msecs"
+    end
+
+    def get_times(results, levels)
+      times = Array.new
+      times.push(make_milli(results[0]))
+      levels.each do |num|
+        times.push(make_milli(results[(results.length*num).to_i]))
+      end
+      times.push(make_milli(results[-1]))
+    end
+
+    def make_milli(num)
+      (num * 1000).to_i
+    end
+
+    def report_header
+      print <<EOF
+Concurrency Level:       #{@max_threads}
+Total Requests:          #{@max_runs}
+Total time for testing:  #{@total_time} secs
+Requests per second:     #{@max_runs/@total_time}
+Mean time per request:   #{results_mean}  msecs
+Standard deviation:      #{results_std_dev}
+EOF
+      end
+
+      def build_thread
+        if @current_threads < @max_threads
+          @current_runs += 1
+          @threads << Thread.new { run_test(@current_runs)}
+          @current_threads += 1
+        end
+      end
+
+      def run_test(id)
+        request = @urls.get_url
+        url = URI.parse request.to_url
+        base = request.to_base
+        start_time = Time.now
+        response_code = nil
+
+        @http.start(url.host, url.port) do |http|
+          response = http.request( Net::HTTP::Get.new(url) )
+          response_code = response.code
+        end
+
+        stop_time = Time.now
+        time = stop_time - start_time
+        
+        result = Result.new(id, Time.now, base, time, response_code)
+        
+        @new_results.add_result(result)
+        @current_threads -= 1
+      end
+    end
+
+  end

data/test/test_rwb.rb

@@ -0,0 +1,362 @@
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+require 'rwb'
+
+module RWB
+  class Runner
+    attr_writer :results_mean, :results_std_dev
+  end
+end
+
+
+module TestRWB
+  class TestBuilder < Test::Unit::TestCase
+    def setup
+      @urls = RWB::Builder.new
+    end
+
+    def test_add_url
+      @urls.add_url(20, "http://localhost")
+      assert_equal(1, @urls.urls.length)
+      assert_equal("http://localhost", @urls.get_url.to_url)
+    end
+
+    def test_add_url_group
+      @urls.add_url_group(20, "http://localhost/search?", ['foo', 'bar'])
+      assert_equal(1, @urls.urls.length)
+      assert_instance_of(RWB::UrlGroup, @urls.get_url)
+      assert_equal(20, @urls.get_url.weight)
+    end
+
+    def test_build_urls
+      config = {
+        "http://localhost" => 20,
+        "http://localhost/nonesuch" => 20}
+      @urls.build_urls(config)
+      assert_equal(2, @urls.urls.length)
+    end
+
+    def test_get_url
+      @urls.add_url(20, "http://localhost")
+      assert_equal("http://localhost", @urls.get_url.to_url)
+      @urls.add_url(20, "http://localhost/foo")
+      assert_equal("http://localhost", @urls.get_url(1).to_url)
+      assert_equal("http://localhost", @urls.get_url(2).to_url)
+      assert_equal("http://localhost/foo", @urls.get_url(3).to_url)
+    end
+
+    def test_total_weight
+      @urls.add_url(20, "http://localhost")
+      assert_equal(20, @urls.total_weight)
+      @urls.add_url(20, "http://localhost/foo")
+      assert_equal(40, @urls.total_weight)
+    end
+
+    def test_urls
+      @urls.add_url(20, "http://localhost")
+      @urls.add_url(20, "http://localhost/foo")
+      assert_instance_of(Hash, @urls.urls)
+      assert_instance_of(RWB::Url, @urls.urls[20])
+      assert_equal([40, 20], @urls.urls.keys)
+    end
+  end
+
+  class TestRunner < Test::Unit::TestCase
+    def test_build_thread
+      #raise NotImplementedError, 'Need to write test_build_thread'
+    end
+
+    def test_get_times
+      #raise NotImplementedError, 'Need to write test_get_times'
+    end
+
+    def test_make_milli
+      tests = RWB::Runner.new(nil)
+      assert_equal(23, tests.make_milli(0.023))
+    end
+
+
+    def test_results_quartile
+      times = [0.011, 0.134, 0.199, 0.212, 0.236, 0.275, 
+        0.351, 0.401, 0.479, 0.603, 0.758, 0.978]
+      quartile_graph = 
+         "0[        |---+---------|                        ]:1000"
+      test = RWB::Runner.new(nil)
+      test.results_mean = 450
+      test.results_std_dev = 200
+      assert_equal(quartile_graph, test.results_quartile(times))
+    end
+
+    def test_results_quartile_half_step
+      times = [0.011, 0.134, 0.199, 0.212, 0.236, 0.275, 
+        0.322, 0.351, 0.379, 0.403, 0.458, 0.478]
+      quartile_graph = 
+        "0:[                 |-------+---------|         ] :500"
+      test = RWB::Runner.new(nil)
+      test.results_mean = 450
+      test.results_std_dev = 200
+      assert_equal(quartile_graph, test.results_quartile(times))
+    end
+
+    def test_results_quartile_mid_values
+      times = [0.011, 0.013, 0.019, 0.021, 0.023, 0.027, 
+        0.035, 0.040, 0.047, 0.060, 0.075, 0.085]
+      quartile_graph = 
+         "0:    [   |---+---------|                  ]      :100"
+      test = RWB::Runner.new(nil)
+      test.results_mean = 45
+      test.results_std_dev = 20
+      assert_equal(quartile_graph, test.results_quartile(times))
+    end
+
+    def test_results_quartile_small_values
+      times = [0.001, 0.002, 0.003,0.004,0.005,0.006,
+        0.007,0.008,0.009]
+      quartile_graph = 
+         "0:[|-+-|  ]                                       :50"
+      test = RWB::Runner.new(nil)
+      test.results_mean = 4
+      test.results_std_dev = 2
+      assert_equal(quartile_graph, test.results_quartile(times))
+    end
+
+    def test_results_quartile_set_scale
+      times = [0.001, 0.002, 0.003,0.004,0.005,0.006,
+        0.007,0.008,0.009]
+      quartile_graph = 
+         "0]                                                :1000"
+      test = RWB::Runner.new(nil)
+      test.results_mean = 4
+      test.results_std_dev = 2
+      assert_equal(quartile_graph, test.results_quartile(times, 1000))
+    end
+
+    def test_adjust_scale
+      test = RWB::Runner.new(nil)
+      assert_equal(25, test.adjust_scale(100,15))
+      assert_equal(50, test.adjust_scale(100,49))
+      assert_equal(100, test.adjust_scale(100,75))
+    end
+
+    def test_print_times
+      #raise NotImplementedError, 'Need to write test_print_times'
+    end
+
+    def test_report_by_time
+      #raise NotImplementedError, 'Need to write test_report_by_time'
+    end
+
+    def test_report_full
+      #raise NotImplementedError, 'Need to write test_report_full'
+    end
+
+    def test_report_header
+      #raise NotImplementedError, 'Need to write test_report_header'
+    end
+
+    def test_report_overall
+      #raise NotImplementedError, 'Need to write test_report_overall'
+    end
+
+    def test_report_urls
+      #raise NotImplementedError, 'Need to write test_report_urls'
+    end
+
+    def test_run_test
+      # not testing yet ...
+      #raise NotImplementedError, 'Need to write test_run_test'
+    end
+
+  end
+
+  class TestUrl < Test::Unit::TestCase
+    def setup
+      @url = RWB::Url.new(10, "http://www.example.com")
+    end
+
+    def test_to_base
+      assert_equal("http://www.example.com", @url.to_base)
+    end
+
+    def test_to_url
+      assert_equal("http://www.example.com", @url.to_url)
+    end
+
+    def test_weight
+      assert_equal(10, @url.weight)
+    end
+  end
+ 
+  class TestUrlGroup < Test::Unit::TestCase
+    def setup
+      queries = ["foo", "bar", "baz"]
+      @url = RWB::UrlGroup.new(10, "http://www.example.com/search?", queries)
+    end
+
+    def test_to_base
+      assert_equal("http://www.example.com/search?", @url.to_base)
+    end
+
+    def test_to_url
+      assert_equal("http://www.example.com/search?foo", @url.to_url(1))
+      assert_equal("http://www.example.com/search?baz", @url.to_url(2))
+      assert_equal("http://www.example.com/search?baz", @url.to_url(3))
+    end
+
+    def test_weight
+      assert_equal(10, @url.weight)
+    end
+  end
+
+  class TestResult < Test::Unit::TestCase
+    def setup
+      @now = Time.now
+      @result = RWB::Result.new(1, @now, "http://localhost", 0.234, 200) 
+    end
+
+    def test_id
+      assert_equal 1, @result.id
+    end
+    
+    def test_timestamp
+      assert_instance_of(Time, @result.timestamp)
+      assert_equal(@now, @result.timestamp)
+    end
+
+    def test_url
+      assert_equal("http://localhost", @result.url)
+    end
+
+    def test_elapsed_time
+      assert_equal(0.234, @result.elapsed_time)
+    end
+
+    def test_response_code
+      assert_equal(200, @result.response_code)
+    end
+  end
+
+  class TestRunResults < Test::Unit::TestCase
+    def setup
+      @results = RWB::RunResults.new
+      @now = Time.now
+      @result = RWB::Result.new(1, @now, "http://localhost", 0.234, 200) 
+    end
+
+    def test_results
+      assert_instance_of(Array, @results.results)
+      assert_equal(0, @results.results.length)
+    end
+
+    def test_add_result
+      @results.add_result(@result)
+      assert_equal(1, @results.results.length)
+      assert_instance_of(RWB::Result, @results.results[0])
+    end
+
+    def test_all_by_response_code
+      @results.add_result(@result)
+      assert_instance_of(Array, @results.all_by_response_code(200))
+      assert_equal(1, @results.all_by_response_code(200).length)
+      assert_equal(0, @results.all_by_response_code(404).length)
+      result = RWB::Result.new(2, Time.now, 
+                               "http://localhost/nonesuch",
+                               0.118, 404)     
+      @results.add_result(result)
+      third = RWB::Result.new(3, Time.now, 
+                              "http://localhost",
+                              0.118, 200)
+      @results.add_result(third)
+      assert_equal(2, @results.all_by_response_code(200).length)
+      assert_equal(1, @results.all_by_response_code(404).length)
+    end
+
+    def test_each_by_response_code
+      @results.add_result(@result)
+      result = RWB::Result.new(2, Time.now, 
+                               "http://localhost/nonesuch",
+                               0.118, 404)     
+      @results.add_result(result)
+      third = RWB::Result.new(3, Time.now, 
+                              "http://localhost",
+                              0.118, 200)
+      @results.add_result(third)
+      @results.each_by_response_code(200) do |result|
+        assert_equal(200, result.response_code)
+      end
+
+      @results.each_by_response_code(404) do |result|
+        assert_equal(404, result.response_code)
+      end
+    end
+
+    def test_all_by_url
+      @results.add_result(@result)
+      assert_instance_of(Array, @results.all_by_url("http://localhost"))
+      assert_equal(1, @results.all_by_url("http://localhost").length)
+      result = RWB::Result.new(2, Time.now, 
+                               "http://localhost/nonesuch",
+                               0.118, 404)     
+      @results.add_result(result)
+      third = RWB::Result.new(3, Time.now, 
+                              "http://localhost",
+                              0.118, 200)
+      @results.add_result(third)
+      assert_equal(2, @results.all_by_url("http://localhost").length)
+      assert_equal(1, @results.all_by_url("http://localhost/nonesuch").length)
+    end
+
+    def test_each_by_url
+      @results.add_result(@result)
+      result = RWB::Result.new(2, Time.now, 
+                               "http://localhost/nonesuch",
+                               0.118, 404)     
+      @results.add_result(result)
+      third = RWB::Result.new(3, Time.now, 
+                              "http://localhost",
+                              0.118, 200)
+      @results.add_result(third)
+      @results.each_by_url("http://localhost") do |result|
+        assert_equal("http://localhost", result.url)
+      end
+
+      @results.each_by_url("http://localhost/nonesuch") do |result|
+        assert_equal("http://localhost/nonesuch", result.url)
+      end
+    end
+
+    def test_all_with_id
+      @results.add_result(@result)
+      assert_instance_of(Hash, @results.all_with_id)
+      assert_equal(1, @results.all_with_id.keys.length)
+      result = RWB::Result.new(2, Time.now, 
+                               "http://localhost/nonesuch",
+                               0.118, 404)     
+      @results.add_result(result)
+      third = RWB::Result.new(3, Time.now, 
+                              "http://localhost",
+                              0.118, 200)
+      @results.add_result(third)
+      assert_equal([1,2,3], @results.all_with_id.keys)
+    end
+
+    def test_times_by_url
+      @results.add_result(@result)
+      assert_instance_of(Array, @results.times_by_url("http://localhost"))
+      assert_equal(1, @results.times_by_url("http://localhost").length)
+      result = RWB::Result.new(2, Time.now, 
+                               "http://localhost/nonesuch",
+                               0.118, 404)     
+      @results.add_result(result)
+      third = RWB::Result.new(3, Time.now, 
+                              "http://localhost",
+                              0.118, 200)
+      @results.add_result(third)
+      assert_equal([0.234, 0.118], @results.times_by_url("http://localhost"))
+      assert_equal([0.118], @results.times_by_url("http://localhost/nonesuch"))
+      assert_equal([0.234, 0.118, 0.118], @results.times_by_url)
+    end
+
+  end
+
+end
+

metadata

@@ -0,0 +1,41 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: rwb
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+date: 2005-12-02
+summary: "Ruby Web Bench, a web performance and load testing framework"
+require_paths: 
+  - lib
+email: pat.eyler@gmail.com
+homepage: http://rubyforge.org/projects/rwb
+rubyforge_project: 
+description: 
+autorequire: rwb
+default_executable: 
+bindir: bin
+has_rdoc: "true"
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Pat Eyler
+files: 
+  - NEWS
+  - README
+  - TODO
+  - lib/rwb.rb
+  - test/test_rwb.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []