celluloid-benchmark 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: a8b43cb7f1b3f835c28eef1361299b99b8188a1e
+  data.tar.gz: 2025783e8cc49d76300263cc7df9ba991af36120
+SHA512: 
+  metadata.gz: 1e1bf981e517e15d3c6698c42b7bd5bc388266203bc7a82f09e2824bef6c95d67fef09d0b213113577c6100528c0e7ed107b43c1b9993c65f0c79d65109ba3ad
+  data.tar.gz: b970a27dba6d16cb152c486077cc879de84d6827444ddf968abbb9cd981a5b6c4a8f056510a6a774efd7bce91bbb36f8978b025fa897f9fdf0037ff0d6864eef

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Scott Willson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+Celluloid Benchmark realistically load tests websites.
+
+Write expressive, concise load tests in Ruby. Use [Rubinius](http://rubini.us) and [Celluloid](https://github.com/celluloid/celluloid) 
+for high concurrency. Use [Mechanize](http://mechanize.rubyforge.org) for a realistic (albeit non-JavaScript) browser client.
+
+Getting Started
+===============
+    celluloid-benchmark test/files/runner_test_session.rb
+
+Congrats! You just load-tested the project's Github page.
+
+For your own tests, create a session file and pass its path to celluloid-benchmark.
+
+Simple scenario
+---------------
+    benchmark :home_page, 1
+    get "https://github.com/scottwillson/celluloid-benchmark"
+
+`benchmark :label, duration` means "measure the following requests and group them under 'label'". 
+Duration is optional and defaults to 0.3 seconds.
+
+Find and click a link
+---------------------
+    page = get "/offer/1"
+    buy_now_link = page.links_with(class: "buy_button").first
+
+    benchmark :purchase_new
+    page = get(buy_now_link.href)
+
+Forms
+-----
+    form = page.forms_with(class: "simple_form purchase_form").first
+    form["CARDNO"] = "4111111111111111"
+    submit(form)
+
+HTTP auth
+---------
+    add_auth "https://staging.example.com", "qa", "password"
+
+
+Simulate AJAX
+-------------
+    transact do
+      get "https://example.com/post_zones/AAA1NNN", [], nil, {
+        "Accept" => "application/json, text/javascript, */*; q=0.01",
+        "X-Requested-With" => "XMLHttpRequest"
+      }
+    end
+
+Test data
+---------
+Because test scenarios are plain Ruby, you can drive tests in many different ways. The 
+[Faker gem](http://rubydoc.info/github/stympy/faker/master/frames) is handy
+for random, realistic test data:
+
+    require "faker"
+    first_name = Faker::Name.first_name
+    last_name = Faker::Name.last_name
+    post_town = Faker::Address.city
+
+    form["CN"] = "#{first_name} #{last_name}"
+    form["c[addr][post_town]"] = post_town
+
+The [Forgery gem](http://sevenwire.github.io/forgery/) is good, too.
+
+Celluloid Benchmark can also pull random test data from CSV files. For example:
+
+    get "https://example.com/post_zones/#{random_data(:post_zone)}"
+
+`random_data(:post_zone)` pulls a random line from tmp/data/post_zones.csv
+
+Celluloid Benchmark agents delegate calls to Mechanize. If you need something more complicated 
+than the examples, check out the [Mechanize API](http://mechanize.rubyforge.org/HTTP/Agent.html) and call it directly with `browser.` in your test scenario.
+
+For a longer test, pass in a second duration argument (seconds):
+    celluloid-benchmark my_test_session.rb 180
+
+Why
+===
+I need to simulate a lot of realistic traffic against preproduction code.
+There are many good tools that can put a high load on a static URL (e.g., [ab](http://httpd.apache.org/docs/2.2/programs/ab.html)), and there are a few tools 
+(e.g., [Tsung](http://tsung.erlang-projects.org)) that can generate realistic multiple-URL loads. By "realistic" I mean: follow links, maintain 
+session state from one page to the next, simulate different types of simultaneous visitors (5% admin users + 10% 
+business customers + 75% consumers). I found it difficult to maintain complex scenarios. Our Tsung tests, 
+for instance, exploded into many ERB files that concatenated into a giant Tsung XML config (with some custom Erlang 
+functions). I also wanted control over recording and displaying test results.
+
+Wouldn't it be nice to just write Ruby?
+
+Yes, expect for that Ruby GIL issue. Which led me to Rubinius and Celluloid.
+
+Rubinius is a concurrency-friendly implementation of Ruby, and Celluloid is a nice Ruby actor framework.
+
+Celluloid also works with MRI 1.9 and 2.0, though Celluloid Benchmark can generate more concurrent load with 
+Rubinius. [JRuby](http://jruby.org) should also work well, maybe better.
+
+I've just added features I need, but it should be easy to add more. For example:
+
+  * Pull specific keys/columns from CSV files
+  * Add random "think times" for visitors to pause on pages
+
+Alternatives
+============
+
+Simple
+------
+[ab (Apache Bench)](http://httpd.apache.org/docs/2.2/programs/ab.html)  
+
+[httperf](http://www.hpl.hp.com/research/linux/httperf/)  
+
+[siege](http://freecode.com/projects/siege)  
+
+
+Complex
+-------
+[Tsung](http://tsung.erlang-projects.org)  
+
+[The Grinder](http://grinder.sourceforge.net)  
+
+[JMeter](http://jmeter.apache.org)  
+
+
+Develop
+=======
+    ruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go)"
+    curl -L https://get.rvm.io | bash
+    rvm install rbx-2.2.1
+    git clone git@github.com:scottwillson/celluloid-benchmark.git
+    cd celluloid-benchmark
+    rvm gemset use celluloid-benchmark --create
+    bundle
+    rake

data/bin/celluloid-benchmark

@@ -0,0 +1,16 @@
+#! /usr/bin/env ruby
+
+require_relative "../lib/celluloid_benchmark"
+
+benchmark_run = CelluloidBenchmark::Runner.run ARGV[0], (ARGV[1] || 20).to_i
+
+p benchmark_run
+puts
+p "#{benchmark_run.requests / benchmark_run.elapsed_time} requests per second. #{benchmark_run.requests} requests in #{benchmark_run.elapsed_time} seconds by #{Celluloid::Actor[:visitor_pool].size} visitors."
+
+puts
+benchmark_run.benchmarks.each do |trans|
+  puts "#{trans.ok? ? '[ OK ]' : '[FAIL]'} #{trans.label}"
+end
+
+exit benchmark_run.ok?

data/lib/celluloid_benchmark.rb

@@ -0,0 +1,5 @@
+module CelluloidBenchmark
+end
+
+require_relative "celluloid_benchmark/version"
+require_relative "celluloid_benchmark/runner"

data/test/files/runner_test_session.rb

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

data/test/integration/config.ru

@@ -0,0 +1,9 @@
+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

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

data/test/integration/html/index.html

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

data/test/integration/integration_test.rb

@@ -0,0 +1,55 @@
+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

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

data/test/unit/benchmark_run_test.rb

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,64 @@
+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

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: celluloid-benchmark
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Scott Willson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-01-09 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: celluloid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.15"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.7"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: racc
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1"
+  type: :runtime
+  version_requirements: *id003
+description: |-
+  Celluloid Benchmark realistically load tests websites. Write expressive, concise load tests in Ruby. Use Rubinius and Celluloid
+  forpec high concurrency. Use Mechanize for a realistic (albeit non-JavaScript) browser client.
+email: scott.willson@gmail.com
+executables: 
+- celluloid-benchmark
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- 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
+homepage: https://github.com/scottwillson/celluloid-benchmark
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id004 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id004
+requirements: []
+
+rubyforge_project: 
+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