wakoopa-trample 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 James Golick
+
+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.rdoc

@@ -0,0 +1,42 @@
+= trample
+
+Trample is a flexible load simulation tool. 
+
+Most load sim tools make requests to a static list of urls. They spawn n threads and make requests to the urls on the list in succession, in each thread. Unfortunately, though, if your applicaition makes use of any kind of caching (including your database's internal caching facilities), this kind of load simulation is unrealistic.
+
+The data required to serve a single set of urls is likely to fit nicely in the database server's cache (even on a small server). So, having a single user hammer a finite set of pages will make your application look much faster than it really is.
+
+Trample allows you to provide parameter values inside of a block (a lambda function, for non-rubyists). The block is executed each time the parameters are needed. So, if you use randomization in the block, you should (theoretically) get different values every time.
+
+That way, you can have trample log in as several different users and request different data in each session.
+
+= How To
+
+Trample uses a ruby DSL for configuration.
+  
+  Trample.configure do
+    concurrency 5
+    iterations  10
+    login do
+      post "http://yoursite.com/login" do
+        {:username => User.random.username, :password => "swordfish"}
+      end
+    end
+    get  "http://yoursite.com/somewhere"
+    post "http://yoursite.com/something" do
+      {:a_parameter => "a value"}
+    end
+    get  "http://yoursite.com/someresources/:id" do
+      {:id => SomeResource.random.id}
+    end
+  end
+
+The above configuration will start 5 (concurrency) sessions by logging in as a random user at the url in the login block. Then, it'll hit the two urls underneath it 10 (iterations) times during each session.
+
+To run trample, save your configuration somewhere and run:
+
+  trample start /path/to/your/trample/config.rb
+
+== Copyright
+
+Copyright (c) 2009 James Golick. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "wakoopa-trample"
+    gem.summary = "A fork of giraffesoft-trample with added functionality for sleeping between requests"
+    gem.email = "wouter@wakoopa.com"
+    gem.homepage = "http://github.com/giraffesoft/trample"
+    gem.authors = ["James Golick", "Wouter Broekhof"]
+
+    gem.add_dependency "sevenwire-rest-client"
+    gem.add_dependency "thor"
+    gem.add_dependency "log4r"
+    gem.add_development_dependency "rake"
+    gem.add_development_dependency "shoulda"
+    gem.add_development_dependency "rr"
+    gem.add_development_dependency "jeweler"
+    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'trample'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 0
+:major: 0

data/bin/trample

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/trample'
+
+Trample::Cli.start
+

data/lib/trample.rb

@@ -0,0 +1,22 @@
+gem 'sevenwire-rest-client'
+require 'log4r'
+require 'rest_client'
+
+module Trample
+  autoload :Configuration, File.dirname(__FILE__) + "/trample/configuration"
+  autoload :Page, File.dirname(__FILE__) + "/trample/page"
+  autoload :Session, File.dirname(__FILE__) + "/trample/session"
+  autoload :Runner, File.dirname(__FILE__) + "/trample/runner"
+  autoload :Cli, File.dirname(__FILE__) + "/trample/cli"
+  autoload :Logging, File.dirname(__FILE__) + "/trample/logging"
+  autoload :Timer, File.dirname(__FILE__) + "/trample/timer"
+
+  class << self
+    attr_reader :current_configuration
+
+    def configure(&block)
+      @current_configuration = Configuration.new(&block)
+    end
+  end
+end
+

data/lib/trample/cli.rb

@@ -0,0 +1,12 @@
+require 'thor'
+
+module Trample
+  class Cli < Thor
+    desc "start path/to/config/file", "Start trampling"
+    def start(config)
+      load(config)
+      Runner.new(Trample.current_configuration).trample
+    end
+  end
+end
+

data/lib/trample/configuration.rb

@@ -0,0 +1,49 @@
+module Trample
+  class Configuration
+    attr_reader :pages
+
+    def initialize(&block)
+      @pages = []
+      instance_eval(&block)
+    end
+
+    def concurrency(*value)
+      @concurrency = value.first unless value.empty?
+      @concurrency
+    end
+
+    def iterations(*value)
+      @iterations = value.first unless value.empty?
+      @iterations
+    end
+
+    def sleep(*value)
+      @sleep = value.first unless value.empty?
+      @sleep
+    end
+
+    def get(url, &block)
+      @pages << Page.new(:get, url, block || {})
+    end
+
+    def post(url, params = nil, &block)
+      @pages << Page.new(:post, url, params || block)
+    end
+
+    def login
+      if block_given?
+        yield
+        @login = pages.pop
+      end
+
+      @login
+    end
+
+    def ==(other)
+      other.is_a?(Configuration) &&
+        other.pages == pages &&
+        other.concurrency == concurrency &&
+        other.iterations  == iterations
+    end
+  end
+end

data/lib/trample/logging.rb

@@ -0,0 +1,14 @@
+module Trample
+  module Logging
+    def logger
+      init_logger if Log4r::Logger['main'].nil?
+      Log4r::Logger['main']
+    end
+
+    protected
+    def init_logger
+      logger = Log4r::Logger.new('main')
+      logger.outputters = Log4r::Outputter.stdout
+    end
+  end
+end

data/lib/trample/page.rb

@@ -0,0 +1,39 @@
+module Trample
+  class Page
+    attr_reader :request_method
+
+    def initialize(request_method, url, parameters = {})
+      @request_method = request_method
+      @url            = url
+      @parameters     = parameters
+    end
+
+    def parameters
+      proc_params? ? @parameters.call : @parameters
+    end
+
+    def ==(other)
+      other.is_a?(Page) && 
+        other.request_method == request_method &&
+          other.url == url
+    end
+
+    def url
+      proc_params? ? interpolated_url : @url
+    end
+    
+    protected
+      def proc_params?
+        @parameters.is_a?(Proc)
+      end
+
+      def interpolated_url
+        params = parameters # cache called proc
+        url    = @url.dup
+        url.scan(/\:\w+/).each do |m|
+          url.gsub!(m, params[m.gsub(/:/, '').to_sym].to_s)
+        end
+        url
+      end
+  end
+end

data/lib/trample/runner.rb

@@ -0,0 +1,28 @@
+module Trample
+  class Runner
+    include Logging
+
+    attr_reader :config, :threads
+
+    def initialize(config)
+      @config  = config
+      @threads = []
+    end
+
+    def trample
+      logger.info "Starting trample..."
+
+      config.concurrency.times do
+        thread = Thread.new(@config) do |c|
+          Session.new(c).trample
+        end
+        threads << thread
+      end
+
+      threads.each { |t| t.join }
+
+      logger.info "Trample completed..."
+    end
+  end
+end
+

data/lib/trample/session.rb

@@ -0,0 +1,47 @@
+module Trample
+  class Session
+    include Logging
+    include Timer
+
+    attr_reader :config, :response_times, :cookies, :last_response
+
+    def initialize(config)
+      @config         = config
+      @response_times = []
+      @cookies        = {}
+    end
+
+    def trample
+      hit @config.login unless @config.login.nil?
+      @config.iterations.times do
+        @config.pages.each do |p|
+          hit p
+        end
+      end
+      sleep @config.sleep unless @config.sleep.nil?
+    end
+
+    protected
+      def hit(page)
+        response_times << request(page)
+        # this is ugly, but it's the only way that I could get the test to pass
+        # because rr keeps a reference to the arguments, not a copy. ah well.
+        @cookies = cookies.merge(last_response.cookies)
+        logger.info "#{page.request_method.to_s.upcase} #{page.url} #{response_times.last}s #{last_response.code}"
+      end
+
+      def request(page)
+        time do
+          @last_response = send(page.request_method, page)
+        end
+      end
+
+      def get(page)
+        RestClient.get(page.url, :cookies => cookies)
+      end
+
+      def post(page)
+        RestClient.post(page.url, page.parameters, :cookies => cookies)
+      end
+  end
+end

data/lib/trample/timer.rb

@@ -0,0 +1,9 @@
+module Trample
+  module Timer
+    def time
+      start = Time.now
+      yield
+      Time.now.to_f - start.to_f
+    end
+  end
+end

data/test/cli_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class CliTest < Test::Unit::TestCase
+  context "Running the CLI" do
+    setup do
+      Trample::Cli.new.start('test/fixtures/basic_config.rb')
+    end
+
+    before_should "start a trample with the current_config" do
+      load('test/fixtures/basic_config.rb')
+      stub.proxy(Trample::Runner).new(Trample.current_configuration) do |r|
+        mock(r).trample
+        r
+      end
+    end
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class ConfigurationTest < Test::Unit::TestCase
+  context "Configuring trample" do
+    setup do
+      @params_proc = lambda { { :q => "the meaning of life" } }
+      @config = Trample::Configuration.new do
+        concurrency 2
+        iterations  1
+        sleep       1
+
+        get "http://google.com/" do
+          {:a => 'b'}
+        end
+        post "http://google.com/", {:q => "something"}
+        post "http://google.com/", &@params_proc
+        login do
+          post "http://google.com/login" do
+            { :q => "whatever" }
+          end
+        end
+      end
+    end
+
+    should "set concurrency" do
+      assert_equal 2, @config.concurrency
+    end
+
+    should "set iterations" do
+      assert_equal 1, @config.iterations
+    end
+
+    should "set sleep" do
+      assert_equal 1, @config.sleep
+    end
+
+    should "add get requests to an array of pages" do
+      assert_equal Trample::Page.new(:get, "http://google.com/"), @config.pages.first
+    end
+
+    should "add get params to the array of pages" do
+      assert_equal({:a => "b"}, @config.pages.first.parameters)
+    end
+
+    should "add post requests to the array of pages, including their params" do
+      expected = Trample::Page.new(:post, "http://google.com/", {:q => "something"})
+      assert_equal expected, @config.pages[1]
+    end
+
+    should "add post requests to the array of pages, including their block-based params" do
+      expected = Trample::Page.new(:post, "http://google.com/", @params_proc)
+      assert_equal expected, @config.pages[2]
+    end
+
+    should "support a login parameter which contains a page to hit with params" do
+      assert_equal "http://google.com/login", @config.login.url
+      assert_equal({:q => "whatever"}, @config.login.parameters)
+    end
+
+    should "be equal if all the objects are the same" do
+      identical_config = Trample::Configuration.new do
+        concurrency 2
+        iterations  1
+        get "http://google.com/"
+        post "http://google.com/", {:q => "something"}
+        post "http://google.com/", &@params_proc
+      end
+      assert_equal identical_config, @config
+    end
+
+    should "not be equal if any of the objects are different" do
+      non_identical_config = Trample::Configuration.new do
+        concurrency 3
+        iterations  1
+        get "http://google.com/"
+      end
+      assert_not_equal non_identical_config, @config
+    end
+  end
+end
+

data/test/fixtures/basic_config.rb

@@ -0,0 +1,5 @@
+Trample.configure do |t|
+  concurrency 2
+  iterations  1
+  get "http://google.com"
+end

data/test/integration/trample_a_single_url_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class TrampleASingleUrlTest < Test::Unit::TestCase
+  def test_trampling_a_single_url
+    mock_get("http://google.com", :times => 2)
+    trample "test/fixtures/basic_config.rb"
+  end
+end
+

data/test/logging_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class LoggingTest < Test::Unit::TestCase
+  context "The logging module" do
+    setup do
+      @object = Class.new do
+        include Trample::Logging
+      end.new
+      @object.send(:init_logger)
+    end
+
+    should "return Log4r::Logger['main'] for #logger" do
+      assert_equal Log4r::Logger['main'], @object.logger
+    end
+  end
+end

data/test/page_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class PageTest < Test::Unit::TestCase
+  context "A page" do
+    setup do
+      @page = Trample::Page.new(:get, "http://google.com/", :username => "joetheuser")
+    end
+
+    should "have a request_method" do
+      assert_equal :get, @page.request_method
+    end
+
+    should "have a url" do
+      assert_equal "http://google.com/", @page.url
+    end
+
+    should "have request parameters" do
+      assert_equal({:username => "joetheuser"}, @page.parameters)
+    end
+
+    should "be equal with the same request_method and url" do
+      assert_equal Trample::Page.new(:get, "http://google.com"), Trample::Page.new(:get, "http://google.com")
+    end
+
+    should "not be equal with a different request_method or url" do
+      assert_not_equal Trample::Page.new(:get, "http://google.com"), Trample::Page.new(:get, "http://google.com/asdf")
+    end
+  end
+
+  context "Block-based request parameters for POST requests" do
+    setup do
+      @page = Trample::Page.new(:post, "http://google.com/:id", lambda { { :id => 1, :username => "joetheuser" } })
+    end
+
+    should "be resolved at call time" do
+      assert_equal({:username => "joetheuser", :id => 1}, @page.parameters)
+    end
+
+    should "interpolate parameters into the url" do
+      assert_equal "http://google.com/1", @page.url
+    end
+  end
+
+  context "Block based parameters for GET requests" do
+    setup do
+      @page = Trample::Page.new(:get, "http://mysite.com/somethings/:id", lambda { {:id => 5} })
+    end
+
+    should "interpolate those parameters with the url string" do
+      assert_equal "http://mysite.com/somethings/5", @page.url
+    end
+
+    should "interpolate a different parameter each time" do
+      page = Trample::Page.new(:get, "http://mysite.com/somethings/:id", lambda { {:id => rand(10)} })
+      assert_not_equal page.url, page.url
+    end
+  end
+end
+

data/test/runner_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class RunnerTest < Test::Unit::TestCase
+  def setup
+    @config = Trample::Configuration.new do  |t| 
+      t.concurrency 2 
+      t.iterations  5
+    end
+  end
+
+  context "Running a trample" do
+    setup do
+      @runner = Trample::Runner.new(@config)
+      @runner.trample
+    end
+
+    before_should "spawn <concurrency> threads" do
+      mock.proxy(Thread).new(@config).times(2)
+    end
+
+    before_should "start <concurrency> sessions trampling" do
+      stub.proxy(Trample::Session).new(@config).times(2) do |s|
+        mock(s).trample
+        s
+      end
+    end
+
+    before_should "block until all the threads terminate" do
+      stub.proxy(Thread).new(@config) do |t|
+        mock(t).join
+        t
+      end
+    end
+  end
+end

data/test/session_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class SessionTest < Test::Unit::TestCase
+  def setup
+    @config = Trample::Configuration.new do
+      iterations 2
+      get "http://google.com/"
+      get "http://amazon.com/"
+      post "http://google.com/"
+    end
+    @session = Trample::Session.new(@config)
+  end
+
+  context "Starting a trample session" do
+    setup do
+      @session.trample
+    end
+
+    before_should "visit the pages iterations times each" do
+      mock_get("http://google.com/", :times => 2)
+      mock_get("http://amazon.com/", :times => 2)
+      mock_post("http://google.com/", :times => 2)
+    end
+  end
+
+  context "Visiting a page" do
+    setup do
+      stub(@session).time { 1.4 }
+      stub(@session).last_response do
+        response = RestClient::Response.new("", stub!)
+        stub(response).cookies { {} }
+        stub(response).code { 200 }
+      end
+      @session.trample
+    end
+
+    should "record the length of time it took to visit that page" do
+      assert_equal [1.4, 1.4, 1.4, 1.4, 1.4, 1.4], @session.response_times
+    end
+  end
+
+  context "If a page responds with a cookie" do
+    should "pass that cookie on to the next page" do
+      stub(RestClient).get(anything, anything) do
+        response = RestClient::Response.new("", stub!)
+        stub(response).cookies { {"xyz" => "abc"} }
+        stub(response).code { 200 }
+      end
+
+      @config = Trample::Configuration.new do
+        iterations 2
+        get "http://amazon.com/"
+      end
+
+      @session = Trample::Session.new(@config)
+      @session.trample
+
+      assert_received(RestClient) { |c| c.get("http://amazon.com/", :cookies => {"xyz" => "abc"}) }
+    end
+  end
+
+  context "A session with login" do
+    # TODO: the order of the requests isn't being tested here. not 
+    # sure if it's possible with rr
+    should "hit the login once at the beginning of the session" do
+      @config = Trample::Configuration.new do
+        iterations 2
+        login do
+          post "http://google.com/login" do
+            {:user => "xyz", :password => "swordfish"}
+          end
+        end
+        get "http://google.com/"
+      end
+      stub_get(anything, :times => 2)
+      mock_post("http://google.com/login", :payload => {:user => "xyz", :password => "swordfish"}, :times => 1)
+      Trample::Session.new(@config).trample
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'rr'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'trample'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit unless include?(RR::Adapters::TestUnit)
+
+  protected
+  def trample(config)
+    Trample::Cli.new.start(config)
+  end
+
+  def mock_get(url, opts={})
+    mock(RestClient).get(url, :cookies => opts[:cookies] || {}).times(opts[:times]) do
+      response = RestClient::Response.new("", stub!)
+      stub(response).cookies { opts[:return_cookies] || {} }
+      stub(response).code { 200 }
+    end
+  end
+
+  def mock_post(url, opts={})
+    mock(RestClient).post(url, opts[:payload],
+                               :cookies => opts[:cookies] || {}).times(opts[:times]) do
+      response = RestClient::Response.new("", stub!)
+      stub(response).cookies { opts[:return_cookies] || {} }
+      stub(response).code { 200 }
+    end
+  end
+
+  def stub_get(url, opts = {})
+    stub(RestClient).get(url, :cookies => opts[:cookies] || {}).times(opts[:times]) do
+      response = RestClient::Response.new("", stub!)
+      stub(response).cookies { opts[:return_cookies] || {} }
+      stub(response).code { 200 }
+    end
+  end
+end
+

data/test/timer_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class TimerTest < Test::Unit::TestCase
+  context "Timing the execution of a block" do
+    setup do
+      now         = Time.now
+      invocations = 0
+      stub(Time).now do
+        invocations += 1
+        # not sure why we have to start at 1, 
+        # but this seems to get called somewhere
+        invocations == 2 ? now : (now + 1.5) 
+      end
+
+      @obj = Class.new { include Trample::Timer }.new
+    end
+
+    should "return the amount of time elapsed while the block was run" do
+      assert_equal(1.5, @obj.time {})
+    end
+  end
+end
+

data/test/trample_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class TrampleTest < Test::Unit::TestCase
+  context "Configuring Trample" do
+    setup do
+      Trample.configure do |t|
+        t.concurrency 5
+        t.iterations  1
+      end
+    end
+
+    should "assign the configuration to Trample.current_configuration" do
+      assert_equal 5, Trample.current_configuration.concurrency
+    end
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification 
+name: wakoopa-trample
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- James Golick
+- Wouter Broekhof
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-23 00:00:00 +01:00
+default_executable: trample
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sevenwire-rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rr
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: wouter@wakoopa.com
+executables: 
+- trample
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- bin/trample
+- lib/trample.rb
+- lib/trample/cli.rb
+- lib/trample/configuration.rb
+- lib/trample/logging.rb
+- lib/trample/page.rb
+- lib/trample/runner.rb
+- lib/trample/session.rb
+- lib/trample/timer.rb
+- test/cli_test.rb
+- test/configuration_test.rb
+- test/fixtures/basic_config.rb
+- test/integration/trample_a_single_url_test.rb
+- test/logging_test.rb
+- test/page_test.rb
+- test/runner_test.rb
+- test/session_test.rb
+- test/test_helper.rb
+- test/timer_test.rb
+- test/trample_test.rb
+has_rdoc: true
+homepage: http://github.com/giraffesoft/trample
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A fork of giraffesoft-trample with added functionality for sleeping between requests
+test_files: 
+- test/cli_test.rb
+- test/configuration_test.rb
+- test/fixtures/basic_config.rb
+- test/integration/trample_a_single_url_test.rb
+- test/logging_test.rb
+- test/page_test.rb
+- test/runner_test.rb
+- test/session_test.rb
+- test/test_helper.rb
+- test/timer_test.rb
+- test/trample_test.rb