celluloid-benchmark 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: a8b43cb7f1b3f835c28eef1361299b99b8188a1e
-  data.tar.gz: 2025783e8cc49d76300263cc7df9ba991af36120
+  metadata.gz: 5d6ca6a307e6c743b6024e66193242e30daebf58
+  data.tar.gz: 13a15f647b8b7fb852f92930e6f16ed3d23019fb
 SHA512: 
-  metadata.gz: 1e1bf981e517e15d3c6698c42b7bd5bc388266203bc7a82f09e2824bef6c95d67fef09d0b213113577c6100528c0e7ed107b43c1b9993c65f0c79d65109ba3ad
-  data.tar.gz: b970a27dba6d16cb152c486077cc879de84d6827444ddf968abbb9cd981a5b6c4a8f056510a6a774efd7bce91bbb36f8978b025fa897f9fdf0037ff0d6864eef
+  metadata.gz: fafc822aa34fbde4808ec16a08d3752621bdb5d8c10eb2333c78e2414a00b04a303a3981c14c129ce956f3e4cd12950f114fc0cba90d01792aa3f462536a5cf1
+  data.tar.gz: 03fd8a7cc021d5a1ef7f77c9abd647b752b762a5a7c8c98b6b1e3ac47e250263e71615e7c1c28e0dddd2d4a5f819d7b97c0597d400fc1c110d6fad0d2c2133e2

data/README.md

@@ -5,7 +5,10 @@ for high concurrency. Use [Mechanize](http://mechanize.rubyforge.org) for a real
 
 Getting Started
 ===============
-    celluloid-benchmark test/files/runner_test_session.rb
+    gem install celluloid-benchmark
+    echo "benchmark :home_page, 1
+    get 'https://github.com/scottwillson/celluloid-benchmark'" > session.rb
+    celluloid-benchmark session.rb 1
 
 Congrats! You just load-tested the project's Github page.
 

data/lib/celluloid_benchmark/benchmark.rb

@@ -0,0 +1,50 @@
+module CelluloidBenchmark
+  # List of responses for a benchmark defined in test scenario.
+  #
+  # For example, requests for /offers/1001, /offers/1001-burgerville-deal, /offers/2200 
+  # might all be grouped under the "offer_show" label
+  #
+  # Call #ok? to check that responses were OK and fast enough.
+  class Benchmark
+    attr_reader :label
+    attr_reader :response_codes
+    attr_reader :response_times
+    attr_reader :threshold
+
+    def initialize(label, threshold, response_times, response_codes)
+      raise(ArgumentError, "label cannot be blank") if label.nil? || label == ""
+
+      @label = label
+      @response_times = response_times || []
+      @threshold = threshold || 3.0
+      @response_codes = response_codes || []
+
+      raise(ArgumentError, "threshold must be greater than zero") if self.threshold <= 0
+    end
+    
+    def ok?
+      response_times_ok? && response_codes_ok?
+    end
+
+    # Consider average response time. Do not check for outlying slow times.
+    def response_times_ok?
+      if response_times.size > 0
+        average_response_time <= threshold
+      else
+        true
+      end
+    end
+
+    # 200 OK is ... OK, as is a redirect, not modified, or auth required
+    def response_codes_ok?
+      response_codes.all? { |code| code == 200 || code == 302 || code == 304 || code == 401 }
+    end
+    
+    
+    private
+    
+    def average_response_time
+      response_times.reduce(:+) / response_times.size
+    end
+  end
+end

data/lib/celluloid_benchmark/benchmark_run.rb

@@ -0,0 +1,82 @@
+require "logger"
+
+require "celluloid"
+require_relative "benchmark"
+
+module CelluloidBenchmark
+  # A test run of a scenario. Holds response times, codes, and requests. Reports results as an array of Benchmarks
+  class BenchmarkRun
+    include Celluloid
+
+    attr_accessor :ended_at
+    attr_accessor :logger
+    attr_accessor :started_at
+    attr_reader :thresholds
+
+    def initialize
+      if !Dir.exists?("log")
+        FileUtils.mkdir "log"
+      end
+      
+      # Could replace with Celluloid.logger
+      @logger = ::Logger.new("log/benchmark.log")
+      @thresholds = Hash.new
+    end
+
+    def log(http_status_code, start_time, end_time, label, threshold)
+      time = end_time - start_time
+      response_times[label] << time
+      response_codes[label] << http_status_code.to_i
+      
+      if threshold
+        thresholds[label] = threshold
+      end
+      
+      logger.info "#{http_status_code} #{time} #{label}"
+    end
+
+    def response_times
+      @response_times ||= Hash.new { |hash, value| hash[value] = [] }
+    end
+
+    def response_codes
+      @response_codes ||= Hash.new { |hash, value| hash[value] = [] }
+    end
+  
+    def requests
+      response_times.values.compact.map(&:size).reduce(&:+) || 0
+    end
+  
+    def benchmarks
+      response_times.map do |label, response_times|
+        CelluloidBenchmark::Benchmark.new label, thresholds[label], response_times, response_codes[label]
+      end
+    end
+    
+    def mark_start
+      @started_at = Time.now
+    end
+    
+    def mark_end
+      @ended_at = Time.now
+    end
+    
+    def elapsed_time
+      if started_at && ended_at
+        (ended_at - started_at).to_f
+      else
+        0
+      end
+    end
+  
+    def ok?
+      benchmarks.all?(&:ok?)
+    end
+
+    def inspect
+      response_times.map do |label, response_times|
+        "#{label} #{response_times.reduce(:+) / response_times.size} #{response_times.min} #{response_times.max} #{response_times.size}"
+      end
+    end
+  end
+end

data/lib/celluloid_benchmark/runner.rb

@@ -0,0 +1,34 @@
+require "celluloid"
+require_relative "visitor_group"
+
+Celluloid.logger = nil
+
+module CelluloidBenchmark
+  # Run a scenario in several Visitors and return a BenchmarkRun
+  class Runner
+    def self.run(session_path, duration = 10)
+      raise("session_path is required") unless session_path
+      raise("'#{session_path}' does not exist")  unless File.exists?(session_path)
+      
+      visitor_group = VisitorGroup.run!
+      benchmark_run = Celluloid::Actor[:benchmark_run]
+
+      benchmark_run.mark_start
+      futures = run_sessions(session_path, benchmark_run, duration)
+      futures.map(&:value)
+      benchmark_run.mark_end
+
+      benchmark_run
+    end
+    
+    def self.run_sessions(session_path, benchmark_run, duration)
+      session = File.read(session_path)
+      visitors = Celluloid::Actor[:visitor_pool]
+      futures = []
+      (visitors.size - 2).times do
+        futures << visitors.future.run_session(session, benchmark_run, duration)
+      end
+      futures
+    end
+  end
+end

data/lib/celluloid_benchmark/version.rb

@@ -0,0 +1,3 @@
+module CelluloidBenchmark
+  VERSION = "0.0.2"
+end

data/lib/celluloid_benchmark/visitor.rb

@@ -0,0 +1,79 @@
+require "mechanize"
+
+module CelluloidBenchmark
+  # Actor that models a person using a web browser. Runs a test scenario. Delegates web browsing to 
+  # instance of a Mechanize Agent.
+  class Visitor
+    include Celluloid
+    extend Forwardable
+
+    def_delegators :@browser, :add_auth, :get, :submit, :transact
+
+    attr_reader :benchmark_run
+    attr_reader :browser
+    attr_accessor :current_request_label
+    attr_accessor :current_request_threshold
+    attr_accessor :request_start_time
+    attr_accessor :request_end_time
+
+    def initialize(browser = Mechanize.new)
+      @browser = browser
+
+      browser.pre_connect_hooks << proc do |agent, request|
+        self.request_start_time = Time.now
+      end
+
+      browser.post_connect_hooks << proc do |agent, uri, response, body|
+        self.request_end_time = Time.now
+        benchmark_run.async.log response.code, request_start_time, request_end_time, current_request_label, current_request_threshold
+      end
+    end
+
+    def run_session(session, benchmark_run, duration)
+      @benchmark_run = benchmark_run
+
+      elapsed_time = 0
+      started_at = Time.now
+      until elapsed_time >= duration
+        begin
+          instance_eval session
+        rescue Mechanize::ResponseCodeError => e
+          self.request_end_time = Time.now
+          benchmark_run.async.log(
+            e.response_code, 
+            request_start_time, 
+            request_end_time, 
+            current_request_label, 
+            current_request_threshold
+          )
+        end
+        
+        elapsed_time = Time.now - started_at
+      end
+      elapsed_time
+    end
+  
+    def benchmark(label, threshold = 0.5)
+      self.current_request_label = label
+      self.current_request_threshold = threshold
+    end
+
+    def random_data(key)
+      data_source(key).sample
+    end
+    
+    def data_sources
+      @data_sources ||= Hash.new do |hash, key|
+        hash[key] = File.readlines("tmp/data/#{key}s.csv")
+      end
+    end
+    
+    def data_sources=(hash)
+      @data_sources = hash
+    end
+
+    def data_source(key)
+      data_sources[key]
+    end
+  end
+end

data/lib/celluloid_benchmark/visitor_group.rb

@@ -0,0 +1,11 @@
+require "celluloid"
+require_relative "benchmark_run"
+require_relative "visitor"
+
+module CelluloidBenchmark
+  # Supervised Actor pool of Visitors
+  class VisitorGroup < Celluloid::SupervisionGroup
+    supervise BenchmarkRun, as: :benchmark_run
+    pool Visitor, as: :visitor_pool, size: 8
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: celluloid-benchmark
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Scott Willson
@@ -56,16 +56,12 @@ files:
 - README.md
 - bin/celluloid-benchmark
 - lib/celluloid_benchmark.rb
-- test/files/runner_test_session.rb
-- test/integration/config.ru
-- test/integration/html/404.html
-- test/integration/html/index.html
-- test/integration/integration_test.rb
-- test/integration/test_session.rb
-- test/unit/benchmark_run_test.rb
-- test/unit/benchmark_test.rb
-- test/unit/runner_test.rb
-- test/unit/visitor_test.rb
+- lib/celluloid_benchmark/benchmark.rb
+- lib/celluloid_benchmark/benchmark_run.rb
+- lib/celluloid_benchmark/runner.rb
+- lib/celluloid_benchmark/version.rb
+- lib/celluloid_benchmark/visitor.rb
+- lib/celluloid_benchmark/visitor_group.rb
 homepage: https://github.com/scottwillson/celluloid-benchmark
 licenses: 
 - MIT
@@ -92,14 +88,5 @@ rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Pure Ruby, realistic, website load test tool
-test_files: 
-- test/files/runner_test_session.rb
-- test/integration/config.ru
-- test/integration/integration_test.rb
-- test/integration/test_session.rb
-- test/unit/benchmark_run_test.rb
-- test/unit/benchmark_test.rb
-- test/unit/runner_test.rb
-- test/unit/visitor_test.rb
-- test/integration/html/404.html
-- test/integration/html/index.html
+test_files: []
+

data/test/files/runner_test_session.rb

@@ -1,2 +0,0 @@
-benchmark :home_page, 1
-get "https://github.com/scottwillson/celluloid-benchmark"

data/test/integration/config.ru

@@ -1,9 +0,0 @@
-require 'rack/contrib/try_static'
-require 'rack/contrib/not_found'
- 
-use Rack::TryStatic,
-  :root => "test/integration/html",
-  :urls => %w[/],
-  :try  => ['index.html', '/index.html']
- 
-run Rack::NotFound.new('test/integration/html/404.html')

data/test/integration/html/404.html

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>404</title>
-  </head>
-  
-  <body>
-    File not found
-  </body>
-</html>

data/test/integration/html/index.html

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Test page</title>
-  </head>
-  
-  <body>
-    Body
-  </body>
-</html>

data/test/integration/integration_test.rb

@@ -1,55 +0,0 @@
-require "minitest/autorun"
-require_relative "../../lib/celluloid_benchmark"
-
-module CelluloidBenchmark
-  class IntegrationTest < Minitest::Test
-    def setup
-      # minitest and Celluloid both use at_exit
-      Celluloid.boot
-      
-      start_target_webserver
-    end
-    
-    def teardown
-      stop_target_webserver
-    end
-
-    def test_happy_path
-      assert target_webserver_responsive?, "Test web server did not respond OK"
-      
-      session_path = File.expand_path(File.dirname(__FILE__) + "/test_session.rb")
-      duration = 5
-      benchmark_run = CelluloidBenchmark::Runner.run(session_path, duration)
-
-      assert benchmark_run.ok?, "Run should be OK"
-    end
-    
-    def start_target_webserver
-      `thin --threaded --rackup test/integration/config.ru --daemonize --port 8000 start`
-    end
-    
-    def stop_target_webserver
-      `thin stop`
-    end
-    
-    def target_webserver_responsive?
-      require "net/http"
-      require "uri"
-
-      uri = URI.parse("http://localhost:8000/")
-      http = Net::HTTP.new(uri.host, uri.port)
-      Timeout::timeout(5) do
-        request = Net::HTTP::Get.new(uri.request_uri)
-        begin
-          response = http.request(request)
-          if response.code.to_i == 200
-            return true
-          end
-        rescue Errno::ECONNREFUSED, Net::HTTP::Persistent::Error
-          # Ignore. Server might be starting up.
-        end
-        sleep 1
-      end
-    end
-  end
-end

data/test/integration/test_session.rb

@@ -1,2 +0,0 @@
-benchmark :home_page, 1
-get "http://localhost:8000/"

data/test/unit/benchmark_run_test.rb

@@ -1,130 +0,0 @@
-require "minitest/autorun"
-require "timecop"
-require_relative "../../lib/celluloid_benchmark/benchmark_run"
-
-module CelluloidBenchmark
-  class BenchmarkRunTest < Minitest::Test
-    def setup
-      # minitest and Celluloid both use at_exit
-      Celluloid.boot
-    end
-
-    def test_new
-      BenchmarkRun.new
-    end
-
-    def test_inspect
-      BenchmarkRun.new.inspect
-    end
-
-    def test_log
-      benchmark_run = BenchmarkRun.new
-      logger = Minitest::Mock.new
-      logger.expect :info, true, [ "200 1 search"]
-      benchmark_run.logger = logger
-      benchmark_run.log 200, 1, 2, "search", 3
-    end
-    
-    def test_response_times
-      benchmark_run = BenchmarkRun.new
-      assert_equal Hash.new, benchmark_run.response_times
-      
-      benchmark_run.log 200, 3, 4, "search", 0
-      assert_equal({ "search" => [ 1 ] }, benchmark_run.response_times)
-      
-      benchmark_run.log 200, 40, 100, "search", 3
-      search_times = benchmark_run.response_times[ "search" ]
-      assert_equal [ 1, 60 ], search_times.sort
-      
-      benchmark_run.log 404, 1000, 2000, "home", 3
-      search_times = benchmark_run.response_times[ "search" ]
-      assert_equal [ 1, 60 ], search_times.sort
-      assert_equal [ 1000 ], benchmark_run.response_times[ "home" ]
-    end
-    
-    def test_response_codes
-      benchmark_run = BenchmarkRun.new
-      assert_equal Hash.new, benchmark_run.response_codes
-      
-      benchmark_run.log 200, 3, 4, "search", 0
-      assert_equal({ "search" => [ 200 ] }, benchmark_run.response_codes)
-      
-      benchmark_run.log 302, 40, 100, "search", 3
-      search_codes = benchmark_run.response_codes[ "search" ]
-      assert_equal [ 200, 302 ], search_codes.sort
-      
-      benchmark_run.log 404, 1000, 2000, "home", 3
-      search_codes = benchmark_run.response_codes[ "search" ]
-      assert_equal [ 200, 302 ], search_codes.sort
-      assert_equal [ 404 ], benchmark_run.response_codes[ "home" ]
-    end
-    
-    def test_requests
-      benchmark_run = BenchmarkRun.new
-      assert_equal 0, benchmark_run.requests
-
-      benchmark_run.log 200, 3, 4, "search", 0
-      assert_equal 1, benchmark_run.requests
-
-      benchmark_run.log 200, 3, 4, "search", 0
-      assert_equal 2, benchmark_run.requests
-    end
-    
-    def test_benchmarks
-      benchmark_run = BenchmarkRun.new
-      assert_equal 0, benchmark_run.benchmarks.size
-      assert benchmark_run.benchmarks.empty?
-      
-      benchmark_run.log 200, 3, 4, "search", 0.01
-      assert_equal 1, benchmark_run.benchmarks.size
-      benchmark = benchmark_run.benchmarks.first
-      assert_equal "search", benchmark.label, "benchmark label"
-      assert_equal 0.01, benchmark.threshold, "benchmark threshold"
-      assert_equal [ 1 ], benchmark.response_times, "benchmark response_times"
-      assert_equal [ 200 ], benchmark.response_codes, "benchmark response_codes"
-    end
-    
-    def test_mark_start
-      benchmark_run = BenchmarkRun.new
-      assert_equal nil, benchmark_run.started_at, "started_at"
-
-      Timecop.freeze(Time.new(2001, 4, 5, 18, 30)) do
-        benchmark_run.mark_start
-      end
-      
-      assert_equal Time.new(2001, 4, 5, 18, 30), benchmark_run.started_at
-    end
-    
-    def test_mark_end
-      benchmark_run = BenchmarkRun.new
-      assert_equal nil, benchmark_run.ended_at, "ended_at"
-
-      Timecop.freeze(Time.new(2001, 4, 5, 18, 30)) do
-        benchmark_run.mark_end
-      end
-      
-      assert_equal Time.new(2001, 4, 5, 18, 30), benchmark_run.ended_at
-    end
-    
-    def test_ok
-      benchmark_run = BenchmarkRun.new
-      assert benchmark_run.ok?
-      
-      benchmark_run.stub :benchmarks, [ Minitest::Mock.new.expect(:ok?, true) ] do
-        assert benchmark_run.ok?
-      end
-      
-      benchmark_run.stub :benchmarks, [ Minitest::Mock.new.expect(:ok?, true), Minitest::Mock.new.expect(:ok?, true) ] do
-        assert benchmark_run.ok?
-      end
-      
-      benchmark_run.stub :benchmarks, [ Minitest::Mock.new.expect(:ok?, false), Minitest::Mock.new.expect(:ok?, true) ] do
-        assert !benchmark_run.ok?
-      end
-      
-      benchmark_run.stub :benchmarks, [ Minitest::Mock.new.expect(:ok?, false), Minitest::Mock.new.expect(:ok?, false) ] do
-        assert !benchmark_run.ok?
-      end
-    end
-  end
-end

data/test/unit/benchmark_test.rb

@@ -1,107 +0,0 @@
-require "minitest/autorun"
-require_relative "../../lib/celluloid_benchmark/benchmark"
-
-module CelluloidBenchmark
-  class BenchmarkTest < Minitest::Test
-    def test_require_label
-      assert_raises ArgumentError do
-        Benchmark.new(nil, 1, [], [])
-      end
-    end
-    
-    def test_require_threshold_above_zero
-      assert_raises ArgumentError do
-        Benchmark.new("homepage", 0, nil, nil)
-      end
-    end
-    
-    def test_defaults
-      benchmark = Benchmark.new("homepage", nil, nil, nil)
-      
-      assert_equal 3, benchmark.threshold, "default threshold"
-
-      assert !benchmark.response_codes.nil?, "response_codes default"
-      assert benchmark.response_codes.empty?, "response_codes default"
-
-      assert !benchmark.response_times.nil?, "response_times default"
-      assert benchmark.response_times.empty?, "response_times default"
-    end
-    
-    def test_response_times_ok_for_empty_benchmark
-      benchmark = Benchmark.new("homepage", nil, nil, nil)
-      assert benchmark.ok?, "Empty Benchmark should be OK"
-    end
-
-    def test_ok_if_response_codes_and_times_ok
-      benchmark = Benchmark.new("homepage", nil, nil, nil)
-      
-      benchmark.stub(:response_times_ok?, true) do
-        benchmark.stub(:response_codes_ok?, true) do
-          assert benchmark.ok?, "Benchmark.ok? times OK and codes OK"
-        end
-      end
-      
-      benchmark.stub(:response_times_ok?, false) do
-        benchmark.stub(:response_codes_ok?, true) do
-          assert !benchmark.ok?, "Benchmark.ok? times not OK and codes OK"
-        end
-      end
-      
-      benchmark.stub(:response_times_ok?, true) do
-        benchmark.stub(:response_codes_ok?, false) do
-          assert !benchmark.ok?, "Benchmark.ok? times OK and codes not OK"
-        end
-      end
-      
-      benchmark.stub(:response_times_ok?, false) do
-        benchmark.stub(:response_codes_ok?, false) do
-          assert !benchmark.ok?, "Benchmark.ok? times not OK and codes not OK"
-        end
-      end
-    end
-    
-    def test_blank_response_time_ok
-      benchmark = Benchmark.new("homepage", nil, nil, nil)
-      assert benchmark.response_times_ok?
-    end
-    
-    def test_blank_response_codes_ok
-      benchmark = Benchmark.new("homepage", nil, nil, nil)
-      assert benchmark.response_codes_ok?
-    end
-    
-    def test_response_times
-      benchmark = Benchmark.new("test", 1, [ 0.99, 0.9, 1.01 ], nil)
-      assert benchmark.response_times_ok?
-
-      benchmark = Benchmark.new("test", 1, [ 1.000001, 1, 1 ], nil)
-      assert !benchmark.response_times_ok?
-    end
-    
-    def test_response_codes
-      benchmark = Benchmark.new("test", nil, [], [])
-      assert benchmark.response_codes_ok?
-
-      benchmark = Benchmark.new("test", nil, [], [ 500 ])
-      assert !benchmark.response_codes_ok?
-
-      benchmark = Benchmark.new("test", nil, [], [ 200 ])
-      assert benchmark.response_codes_ok?
-
-      benchmark = Benchmark.new("test", nil, [], [ 200, 500 ])
-      assert !benchmark.response_codes_ok?
-
-      benchmark = Benchmark.new("test", nil, [], [ 200, 302, 304, 401 ])
-      assert benchmark.response_codes_ok?
-
-      benchmark = Benchmark.new("test", nil, [], [ 403, 200, 302, 401 ])
-      assert !benchmark.response_codes_ok?
-
-      benchmark = Benchmark.new("test", nil, [], [ 410, 200, 302, 401 ])
-      assert !benchmark.response_codes_ok?
-
-      benchmark = Benchmark.new("test", nil, [], [ 309, 200, 302, 401 ])
-      assert !benchmark.response_codes_ok?
-    end
-  end
-end

data/test/unit/runner_test.rb

@@ -1,24 +0,0 @@
-require "minitest/autorun"
-require_relative "../../lib/celluloid_benchmark/runner"
-require "fakeweb"
-
-FakeWeb.allow_net_connect = false
-
-module CelluloidBenchmark
-  class BenchmarkRunnerTest < Minitest::Test
-    def setup
-      # minitest and Celluloid both use at_exit
-      Celluloid.boot
-    end
-
-    def test_run
-      FakeWeb.register_uri(:get, "https://github.com/scottwillson/celluloid-benchmark", :body => "<html>OK</html>")
-      benchmark_run = Runner.run(File.dirname(__FILE__) + "/../files/runner_test_session.rb", 0.1)
-      
-      benchmarks = benchmark_run.benchmarks
-      assert_equal 1, benchmarks.size
-      benchmark = benchmarks.first
-      assert benchmark.ok?, "benchmark.ok?"
-    end
-  end
-end

data/test/unit/visitor_test.rb

@@ -1,64 +0,0 @@
-require "minitest/autorun"
-require "celluloid"
-require_relative "../../lib/celluloid_benchmark/visitor"
-
-module CelluloidBenchmark
-  # Visitor#run_session is the central purpose of this gem, but best tested in an integration test,
-  # not a unit test
-  class VisitorTest < Minitest::Test
-    class MockBrowser
-      attr_accessor :post_connect_hooks, :pre_connect_hooks, :uris
-      
-      def initialize
-        @pre_connect_hooks = []
-        @post_connect_hooks = []
-        @uris = []
-      end
-      
-      def get(uri)
-        uris << uri
-      end
-    end
-
-    def setup
-      # minitest and Celluloid both use at_exit
-      Celluloid.boot
-    end
-
-    def test_run_session
-      browser = MockBrowser.new
-      visitor = Visitor.new(browser)
-      session = File.read(File.dirname(__FILE__) + "/../files/runner_test_session.rb")
-
-      elapsed_time = visitor.run_session(session, nil, 0.01)
-      
-      assert !elapsed_time.nil?, "elapsed_time should not be nil"
-      assert elapsed_time > 0, "elapsed_time should be greater than zero, but was #{elapsed_time}"
-    end
-    
-    def test_benchmark
-      browser = MockBrowser.new
-      visitor = Visitor.new(browser)
-      
-      visitor.benchmark("purchase_page", 0.25)
-      
-      assert_equal "purchase_page", visitor.current_request_label, "current_request_label"
-      assert_equal 0.25, visitor.current_request_threshold, "current_request_threshold"
-    end
-    
-    def test_random_data
-      browser = MockBrowser.new
-      visitor = Visitor.new(browser)
-      
-      data_sources = Minitest::Mock.new
-      data_source = Minitest::Mock.new
-
-      data_source.expect :sample, 3
-      data_sources.expect :[], data_source, [ String ]
-
-      visitor.data_sources = data_sources
-
-      assert_equal 3, visitor.random_data("ids")
-    end
-  end
-end