bigbench 0.0.1

data/lib/bigbench/store.rb

@@ -0,0 +1,92 @@
+module BigBench
+  
+  # The store encapsulates the communication with the redis key-value store. To the outside it looks like normal module methods would be
+  # called. It allows the simple starting of a test on multiple bots with the latest test reciept.
+  module Store
+    
+    TEST_RECEIPT_KEY  = "bigbench_test_receipt"
+    RUNNING_KEY       = "bigbench_running"
+    BOTS_KEY          = "bigbench_bots"
+    TRACKINGS_KEY     = "bigbench_trackings"
+    
+    @redis = nil
+    
+    # Setup the redis storage. Default values are <tt>localhost:6379</tt> and no password.
+    # This needs to be called for any bot test
+    def self.setup!(url = "localhost:6379", password = nil)
+      uri = URI(url)
+      @redis = ::Redis.new :host => uri.host, :port => uri.port, :password => password
+      true
+    end
+    
+    # Deletes all BigBench related keys on the redis store
+    def self.reset!
+      return if @redis.nil?
+      
+      @redis.del(TEST_RECEIPT_KEY)
+      @redis.del(RUNNING_KEY)
+      @redis.del(BOTS_KEY)
+      @redis.del(TRACKINGS_KEY)
+    end
+    
+    # Stores the current test receipt for all bots on the redis instance
+    def self.test=(test)
+      if test
+        @redis.set(TEST_RECEIPT_KEY, test)
+      else
+        @redis.del(TEST_RECEIPT_KEY)
+      end
+    end
+    
+    # Gets the current test from the redis
+    def self.test
+      @redis.get(TEST_RECEIPT_KEY)
+    end
+    
+    # Start the tests for all bots by setting the running key
+    def self.start
+      @redis.set(RUNNING_KEY, "1")
+    end
+    
+    # Stops the test for all bots by unsetting the running key
+    def self.stop
+      @redis.set(RUNNING_KEY, "0")
+    end
+    
+    # Returns true if a bot test has been started
+    def self.running?
+      @redis.get(RUNNING_KEY) == "1"
+    end
+    
+    # Adds a bot to the currently working bots list
+    def self.bot_is_working(id)
+      @redis.sadd(BOTS_KEY, id)
+    end
+    
+    # Removes a bot to the currently working bots list
+    def self.bot_stopped_working(id)
+      @redis.srem(BOTS_KEY, id)
+    end
+    
+    # Shows all currently working bots
+    def self.bots
+      @redis.smembers(BOTS_KEY)
+    end
+    
+    # Add a tracking to the trackings
+    def self.add_tracking(tracking)
+      @redis.rpush(TRACKINGS_KEY, tracking)
+    end
+    
+    # Pop a tracking from the beginning of the list
+    def self.pop_tracking
+      @redis.lpop(TRACKINGS_KEY)
+    end
+    
+    # How many trackings are in the list
+    def self.count_trackings
+      @redis.llen(TRACKINGS_KEY)
+    end
+    
+  end
+end

data/lib/bigbench/tracker.rb

@@ -0,0 +1,79 @@
+module BigBench
+  
+  # The tracker records all request results a benchmark makes. When the benchmark is finished, the trackings are written depending on the mode
+  # of BigBench:
+  #
+  # [config.mode == :bot]     All trackings are appended to the redis store's tracking key
+  # [config.mode == :local]   All trackings are written straight to the file defined by <tt>config.output</tt>
+  # [config.mode == :bots]    All trackings are imported from the redis store's tracking key and written to the file defined by <tt>config.output</tt>
+  #
+  module Tracker
+    
+    class Tracker
+      
+      attr_accessor :trackings
+      
+      def initialize
+        @trackings = []
+      end
+      
+      def track object
+        @trackings << object.to_json
+      end
+    end
+    
+  end
+  
+  # Writes the trackings of a bot to the redis after he finishes the run
+  def self.write_trackings_to_store!
+    trackings, counter = 0, 0
+    BigBench.benchmarks.each{ |benchmark| trackings += benchmark.tracker.trackings.size }
+    BigBench::Output.writing_trackings(trackings)
+    
+    BigBench.benchmarks.each do |benchmark|
+      benchmark.tracker.trackings.each do |tracking|
+        BigBench::Output.wrote_trackings(counter) if counter % 100 == 0
+        BigBench::Store.add_tracking(tracking)
+        counter += 1
+      end
+    end
+    
+    BigBench::Output.finished_writing_trackings(counter)
+  end
+  
+  # Writes the locals trackings from the benchmark to a file
+  def self.write_local_trackings_to_file!
+    trackings, counter = 0, 0
+    BigBench.benchmarks.each{ |benchmark| trackings += benchmark.tracker.trackings.size }
+    BigBench::Output.writing_trackings(trackings)
+    
+    File.open(BigBench.config.output, "w+") do |file|
+      BigBench.benchmarks.each do |benchmark|
+        benchmark.tracker.trackings.each do |tracking|
+          BigBench::Output.wrote_trackings(counter) if counter % 100 == 0
+          file.write tracking + "\n"
+          counter += 1
+        end
+      end
+    end
+    
+    BigBench::Output.finished_writing_trackings(counter)
+  end
+  
+  # Gathers the trackings from the redis and writes them to a local file
+  def self.write_store_trackings_to_file!
+    trackings, counter = BigBench::Store.count_trackings, 0
+    BigBench::Output.writing_trackings(trackings)
+    
+    File.open(BigBench.config.output, "w+") do |file|
+      while tracking = BigBench::Store.pop_tracking do
+        BigBench::Output.wrote_trackings(counter) if counter % 100 == 0
+        file.write tracking + "\n"
+        counter += 1
+      end
+    end
+    
+    BigBench::Output.finished_writing_trackings(counter)
+  end
+  
+end

data/lib/bigbench/version.rb

@@ -0,0 +1,3 @@
+module BigBench
+  VERSION = "0.0.1"
+end

data/spec/benchmark_spec.rb

@@ -0,0 +1,69 @@
+require_relative "./helpers"
+
+describe BigBench::Benchmark do
+  
+  it "should add an empty benchmark with a name" do
+    BigBench.benchmark "a test page" => "http://localhost:3001"
+    BigBench.benchmark "a second test page" => "http://localhost:3001"
+    BigBench.benchmarks.size.should == 0
+  end
+  
+  it "should add a benchmark block with a get fragment" do
+    BigBench.benchmark "a test page" => "http://localhost:3001" do
+      get "/"
+    end
+    
+    BigBench.benchmarks.size.should == 1
+    BigBench.benchmarks.first.fragments.size.should == 1
+    BigBench.benchmarks.first.threads.should == 1
+    BigBench.benchmarks.first.fragments.first.uri.to_s.should == "http://localhost:3001/"
+  end
+  
+  it "should add a benchmark with custom threads" do    
+    BigBench.benchmark "a test page" => "http://localhost:3001", :threads => 20 do
+      get "/"
+    end
+    
+    BigBench.benchmarks.size.should == 1
+    BigBench.benchmarks.first.fragments.size.should == 1
+    BigBench.benchmarks.first.threads.should == 20
+  end
+  
+  it "should return the longest duration of all benchmarks" do
+    BigBench.benchmark "a test page" => "http://localhost:3001", :duration => 1.second do
+      get "/"
+    end
+    
+    BigBench.benchmark "a test page" => "http://localhost:3001", :duration => 3.minutes do
+      get "/"
+    end
+    
+    BigBench.benchmark "a test page" => "http://localhost:3001", :duration => 20.seconds do
+      get "/"
+    end
+    
+    BigBench.duration.should == 3.minutes
+  end
+  
+  context "should run an entire benchmark" do
+    
+    it "make 3 GETs" do
+      
+      benchmark = BigBench.benchmark "a test page" => "http://localhost:3001" do
+        get "/"
+        get "/index"
+        get "/blog"
+      end
+      
+      benchmark.run!
+      benchmark.tracker.trackings.size.should > 100
+      benchmark.runs.should == 1
+      
+      benchmark.run!
+      benchmark.tracker.trackings.size.should > 100
+      benchmark.runs.should == 2
+    end
+    
+  end
+  
+end

data/spec/bot_spec.rb

@@ -0,0 +1,31 @@
+require_relative "./helpers"
+
+describe BigBench::Bot do
+  
+  before(:each) do
+    BigBench::Store.reset!
+  end
+  
+  it "should check for an empty receipt" do
+    BigBench::Store.setup!("http://localhost:6379").should be_true
+    
+    BigBench::Bot.check_test!
+    BigBench.benchmarks.size.should == 0
+  end
+  
+  it "should load and run a test from the redis store" do
+    BigBench::Store.setup!("http://localhost:6379").should be_true
+    
+    test = File.open("spec/tests/local.rb", "rb"){ |file| file.read }
+    BigBench::Store.test = test
+    BigBench::Store.start
+    
+    BigBench::Bot.check_test!
+    
+    BigBench.config.mode.should == :bot
+    BigBench.benchmarks.size.should == 2
+    BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 1 }
+    BigBench::Store.count_trackings.should > 100
+  end
+  
+end

data/spec/configure_spec.rb

@@ -0,0 +1,39 @@
+require_relative "./helpers"
+
+describe BigBench::Configuration do
+  
+  it "should store the config values" do
+    
+    BigBench.configure = {
+      :duration => 10.seconds,
+      :output   => "test.ljson",
+      :threads  => 20
+    }
+    
+    BigBench.config.duration.should == 10.seconds
+    BigBench.config.output.should == "test.ljson"
+    BigBench.config.threads.should == 20
+    
+  end
+  
+  it "should allow to set options seperately" do
+    BigBench.config.duration = 5.seconds
+    BigBench.config.duration.should == 5.seconds
+  end
+  
+  it "should check the minimal options" do
+    BigBench.config.should_not be_valid
+    
+    BigBench.configure = {
+      :duration => 10.seconds,
+      :output   => "test.ljson",
+      :threads  => 20
+    }
+    BigBench.config.should be_valid
+  end
+  
+  it "should allow to check the validity of the config" do
+    lambda {BigBench.check_config!}.should raise_error(BigBench::Configuration::InvalidOptions, "At least: #{BigBench::Configuration::Config::VALIDATE_OPTIONS.join(', ')} are required")
+  end
+  
+end

data/spec/executor_spec.rb

@@ -0,0 +1,80 @@
+require_relative "./helpers"
+
+describe BigBench::Executor do
+  
+  context "should raise an argument error for" do
+    
+    it "nil arguments" do
+      argv = nil
+      lambda{ BigBench::Executor.run!(argv) }.should raise_exception(BigBench::Executor::InvalidCommand)
+    end
+    
+    it "empty arguments" do
+      argv = []
+      lambda{ BigBench::Executor.run!(argv) }.should raise_exception(BigBench::Executor::InvalidCommand)
+    end
+    
+    it "weird arguments" do
+      argv = ["something"]
+      lambda{ BigBench::Executor.run!(argv) }.should raise_exception(BigBench::Executor::InvalidCommand)
+    end
+    
+    it "longer weird arguments" do
+      argv = ["something", "really", "strange"]
+      lambda{ BigBench::Executor.run!(argv) }.should raise_exception(BigBench::Executor::InvalidCommand)
+    end
+    
+  end
+  
+  it "should run a local test with trackings" do    
+    
+    argv = ["run", "local", "spec/tests/local.rb"]
+    BigBench::Executor.run!(argv)
+    
+    BigBench.benchmarks.size.should == 2
+    BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 1 }
+    
+    File.exist?(BigBench.config.output).should be_true
+    File.open(BigBench.config.output) do |file|
+      file.each_line{ |json| JSON.parse(json).is_a?(Hash).should be_true }
+    end
+    
+    File.delete BigBench.config.output
+    
+  end
+  
+  it "should run a bot test" do
+    
+    argv = ["run", "bots", "spec/tests/local.rb"]
+    BigBench::Executor.run!(argv)
+    
+    BigBench.benchmarks.size.should == 2
+    BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 0 }
+    
+    File.exist?(BigBench.config.output).should be_true
+    File.open(BigBench.config.output) do |file|
+      file.each_line{ |json| JSON.parse(json).is_a?(Hash).should be_true }
+    end
+    
+    File.delete BigBench.config.output
+    
+  end
+  
+  it "should show the help file" do
+    argv = ["--help"]
+    lambda{ BigBench::Executor.run!(argv) }.should_not raise_exception
+    File.exists?("lib/bigbench/help/executor.txt").should be_true
+  end
+  
+  it "should reset everything" do
+    BigBench::Store.setup!("http://localhost:6379").should be_true
+    BigBench::Store.test = "something"
+    
+    argv = ["reset", "all"]
+    BigBench::Executor.run!(argv)
+    
+    BigBench.benchmarks.size.should == 0
+    BigBench::Store.test.should be_nil
+  end
+  
+end

data/spec/fragment_spec.rb

@@ -0,0 +1,110 @@
+require_relative "./helpers"
+
+describe BigBench::Fragment do
+  
+  before(:each) do
+    @benchmark = BigBench::Benchmark::Benchmark.new("a test benchmark", "http://localhost:3001", {}){}
+    @benchmark.start = Time.now
+  end
+  
+  it "should parse a single fragment" do
+    fragments = BigBench::Fragment.parse(@benchmark){ get "/" }
+    fragments.size.should == 1
+    fragments.first.uri.to_s.should == "http://localhost:3001/"
+  end
+  
+  it "should parse multiple fragments" do
+    fragments = BigBench::Fragment.parse(@benchmark) do
+      get "/index"
+      get "/page"
+    end
+    fragments.size.should == 2
+    fragments.first.uri.to_s.should == "http://localhost:3001/index"
+    fragments.last.uri.to_s.should == "http://localhost:3001/page"
+  end
+  
+  context "should support following fragment methods" do
+  
+    it "GET" do
+      fragments = BigBench::Fragment.parse(@benchmark){ get "/" }
+      fragments.size.should == 1
+      fragments.first.uri.to_s.should == "http://localhost:3001/"
+      fragments.first.method.should == :get
+      fragments.first.params.should == {}
+    end
+  
+    it "POST" do
+      fragments = BigBench::Fragment.parse(@benchmark){ post "/login", { :user => "tommy@test.com", :password => "secret" } }
+      fragments.size.should == 1
+      fragments.first.uri.to_s.should == "http://localhost:3001/login"
+      fragments.first.method.should == :post
+      fragments.first.params.should == { :user => "tommy@test.com", :password => "secret" }
+    end
+  
+    it "PUT" do
+      fragments = BigBench::Fragment.parse(@benchmark){ put "/books", { :book => "A Book" } }
+      fragments.size.should == 1
+      fragments.first.uri.to_s.should == "http://localhost:3001/books"
+      fragments.first.method.should == :put
+      fragments.first.params.should == { :book => "A Book" }
+    end
+  
+    it "DELETE" do
+      fragments = BigBench::Fragment.parse(@benchmark){ delete "/books/5", { :user => "tommy@test.com", :password => "secret" } }
+      fragments.size.should == 1
+      fragments.first.uri.to_s.should == "http://localhost:3001/books/5"
+      fragments.first.method.should == :delete
+      fragments.first.params.should == { :user => "tommy@test.com", :password => "secret" }
+    end
+  
+  end
+  
+  context "should run following fragment methods" do
+    
+    it "GET" do
+      fragment = BigBench::Fragment.parse(@benchmark){ get "/" }.first
+      result = nil
+      Net::HTTP.start(fragment.uri.host, fragment.uri.port) do |http|
+        result = fragment.run!(http)
+      end
+      result.code.to_i.should == 200
+      result.body.should == "Test"
+      @benchmark.tracker.trackings.size.should == 1
+    end
+    
+    it "POST" do
+      fragment = BigBench::Fragment.parse(@benchmark){ post "/" }.first
+      result = nil
+      Net::HTTP.start(fragment.uri.host, fragment.uri.port) do |http|
+        result = fragment.run!(http)
+      end
+      result.code.to_i.should == 200
+      result.body.should == "Test"
+      @benchmark.tracker.trackings.size.should == 1
+    end
+    
+    it "PUT" do
+      fragment = BigBench::Fragment.parse(@benchmark){ put "/" }.first
+      result = nil
+      Net::HTTP.start(fragment.uri.host, fragment.uri.port) do |http|
+        result = fragment.run!(http)
+      end
+      result.code.to_i.should == 200
+      result.body.should == "Test"
+      @benchmark.tracker.trackings.size.should == 1
+    end
+    
+    it "DELETE" do
+      fragment = BigBench::Fragment.parse(@benchmark){ delete "/" }.first
+      result = nil
+      Net::HTTP.start(fragment.uri.host, fragment.uri.port) do |http|
+        result = fragment.run!(http)
+      end
+      result.code.to_i.should == 200
+      result.body.should == "Test"
+      @benchmark.tracker.trackings.size.should == 1
+    end
+    
+  end
+  
+end