rwb 0.2.1 → 0.2.2

data/lib/rwb.rb

@@ -1,172 +1,12 @@
 require 'net/http'
 require 'uri'
+require 'rwb/url'
+require 'rwb/results'
+require 'rwb/warmup'
+require 'rwb/report'
+require 'open-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
 
@@ -178,14 +18,22 @@ module RWB
       end
     end
 
-    def add_url(weight, url)
+    def add_url(weight, url, method='get')
       @total_weight += weight.to_i
-      @urls[@total_weight] = Url.new(weight, url)
+      @urls[@total_weight] = Url.new(weight, url, method)
+      7
     end
 
-    def add_url_group(weight, base, extension_array)
+    def add_url_group(weight, base, extension_array, method='get')
       @total_weight += weight.to_i
-      @urls[@total_weight] = UrlGroup.new(weight, base, extension_array)
+      @urls[@total_weight] = UrlGroup.new(weight, base, 
+                                          extension_array, method)
+    end
+
+    def add_url_session(weight, session, name, method='get')
+      @total_weight += weight.to_i
+      @urls[@total_weight] = UrlSession.new(weight, session, 
+                                            name, method)
     end
 
     def get_url(seed = nil)
@@ -212,11 +60,8 @@ module RWB
 
     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]
@@ -230,264 +75,62 @@ module RWB
                                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
+      threads = []
+      @steps = []
+      0.step(@max_runs, @max_runs/10) {|i| @steps.push(i) }
+      @requests = (1..@max_runs).to_a
       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
+      for t in 1..@max_threads
+        threads << Thread.new { run_thread }
       end
-      
-      @threads.each { |th| th.join }
-      
+      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
+    def run_thread
+      while req_num = @requests.shift
+        run_test(req_num-1)
+        if @steps.include?(req_num)
+          puts "completed #{req_num} runs"
         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
+    def run_test(id)
+      request = @urls.get_url
+#      url = URI.parse request.to_url
+      base = request.to_base
+      time = nil
+      response_code = nil
       
-      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"
+#      @http.start(url.host, url.port) do |http|
+#        start_time = Time.now
+#        response = http.request( Net::HTTP::Get.new(url) )
+#        stop_time = Time.now
+#        time = stop_time - start_time
+#        response_code = response.code
+#      end
+
+      start_time = Time.now
+      begin
+        open(request.to_url) do |page|
+          stop_time = Time.now
+          time = stop_time - start_time
+          response_code = page.status
         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
-
+      rescue
         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
+        response_code = 404
       end
+      
+      
+      result = Result.new(id, Time.now, base, time, response_code)
+      
+      @new_results.add_result(result)
     end
-
   end
+
+end

data/test/test_rwb.rb

@@ -27,6 +27,13 @@ module TestRWB
       assert_equal(20, @urls.get_url.weight)
     end
 
+    def test_add_session
+      session = ["http://localhost", "http://localhost/foo"]
+      @urls.add_url_session(10, session, 'session1')
+      assert_equal(1, @urls.urls.length)
+      assert_instance_of(RWB::UrlSession, @urls.get_url)
+    end
+
     def test_build_urls
       config = {
         "http://localhost" => 20,
@@ -39,9 +46,18 @@ module TestRWB
       @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)
+      # due to a change in the randomization seed handling between
+      # Ruby 1.8.2 and 1.8.3, we need to check the RUBY_VERSION
+      # and behave accordingly
+      if RUBY_VERSION < "1.8.3"
+        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)
+      else # FIX THESE
+        assert_equal("http://localhost/foo", @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
     end
 
     def test_total_weight
@@ -137,6 +153,19 @@ module TestRWB
       assert_equal(100, test.adjust_scale(100,75))
     end
 
+    def test_get_times
+      test = RWB::Runner.new(nil)
+      assert_equal([100,300,400,500], test.get_times([0.1,0.2,0.3,
+                                                       0.4,0.5],
+                                                     [0.5, 0.75]))
+      assert_equal([100,900,1000], test.get_times([0.1,0.2,0.3,0.4,
+                                                   0.5,0.6,0.7,0.8,
+                                                   0.9,1],[0.9]))
+      assert_equal([100,300,500], test.get_times([0.1,0.2,0.3,
+                                                   0.4,0.5],
+                                                 [0.5,0.9]))
+    end
+
     def test_print_times
       #raise NotImplementedError, 'Need to write test_print_times'
     end
@@ -184,6 +213,27 @@ module TestRWB
     def test_weight
       assert_equal(10, @url.weight)
     end
+    
+    def test_read_method
+      assert_equal('GET', @url.read_method())
+      assert_equal('GET', @url.read_method('get'))
+      assert_equal('GET', @url.read_method('foo'))
+      assert_equal('POST', @url.read_method('post'))
+      assert_equal('POST', @url.read_method('POST'))
+    end
+
+    def test_method
+      assert_equal('GET', @url.method)
+      url = RWB::Url.new(10,"http://www.example.com",'Post')
+      assert_equal('POST', url.method)
+      url = RWB::Url.new(10,"http://www.example.com",'GET')
+      assert_equal('GET', url.method)
+    end
+
+    def test_to_s
+      assert_equal("10 http://www.example.com", @url.to_s)
+    end
+
   end
  
   class TestUrlGroup < Test::Unit::TestCase
@@ -197,14 +247,79 @@ module TestRWB
     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))
+      # due to changes in random seed handling between Ruby 1.8.2 and 1.8.3,
+      # we needdd to check the Ruby version and behave differently
+      if RUBY_VERSION < "1.8.3"
+        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))
+      else  # FIX THESE
+        assert_equal("http://www.example.com/search?bar", @url.to_url(1))
+        assert_equal("http://www.example.com/search?foo", @url.to_url(2))
+        assert_equal("http://www.example.com/search?foo", @url.to_url(2))
+      end
+    end
+
+    def test_weight
+      assert_equal(10, @url.weight)
+    end
+
+    def test_method
+      assert_equal('GET', @url.method)
+      queries = ["foo", "bar", "baz"]
+      url = RWB::UrlGroup.new(10, "http://www.example.com/search?", 
+                              queries, 'post')
+      assert_equal('POST', url.method)
+    end
+
+    def test_to_s
+      assert_equal("10 http://www.example.com/search?", @url.to_s)
+    end
+
+  end
+
+
+  class TestUrlSession < Test::Unit::TestCase
+    def setup
+      session = ["http://www.example.com",
+        "http://www.example.com/browse",
+        "http://www.example.com/detail?foo",
+        "http://www.example.com/detail?bar",
+        "http://www.example.com/browse",
+        "http://www.example.com/logout"]
+      @url = RWB::UrlSession.new(10,session, 'Session 1')
+    end
+
+    def test_to_url
+      assert_equal("http://www.example.com",@url.to_url)
+      assert_equal("http://www.example.com/browse",@url.to_url)
+      assert_equal("http://www.example.com/detail?foo",@url.to_url)
+      assert_equal("http://www.example.com/detail?bar",@url.to_url)
+      assert_equal("http://www.example.com/browse",@url.to_url)
+      assert_equal("http://www.example.com/logout",@url.to_url)
+      assert_equal("http://www.example.com",@url.to_url)
+      assert_equal("http://www.example.com/browse",@url.to_url)
+    end
+
+    def test_to_base
+      assert_equal('Session 1', @url.to_base)
     end
 
     def test_weight
       assert_equal(10, @url.weight)
     end
+
+    def test_method
+      assert_equal('GET', @url.method)
+      session = ["foo", "bar", "baz"]
+      url = RWB::UrlSession.new(10, session, 'Session 2', 'post')
+      assert_equal('POST', url.method)
+    end
+
+    def test_to_s
+      assert_equal("10 Session 1", @url.to_s)
+    end
+
   end
 
   class TestResult < Test::Unit::TestCase

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.8.11
 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"
+  version: 0.2.2
+date: 2007-01-31 00:00:00 -07:00
+summary: Ruby Web Bench, a web performance and load testing framework
 require_paths: 
-  - lib
+- lib
 email: pat.eyler@gmail.com
 homepage: http://rubyforge.org/projects/rwb
 rubyforge_project: 
@@ -18,24 +18,32 @@ bindir: bin
 has_rdoc: "true"
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
 authors: 
-  - Pat Eyler
+- Pat Eyler
 files: 
-  - NEWS
-  - README
-  - TODO
-  - lib/rwb.rb
-  - test/test_rwb.rb
+- NEWS
+- README
+- TODO
+- lib/rwb.rb
+- test/test_rwb.rb
 test_files: []
+
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: []
+
+dependencies: []
+