bigbench 0.0.1 → 0.0.2

data/spec/fragment_spec.rb

@@ -30,7 +30,7 @@ describe BigBench::Fragment do
       fragments.size.should == 1
       fragments.first.uri.to_s.should == "http://localhost:3001/"
       fragments.first.method.should == :get
-      fragments.first.params.should == {}
+      fragments.first.options.should == {}
     end
   
     it "POST" do
@@ -38,7 +38,7 @@ describe BigBench::Fragment do
       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" }
+      fragments.first.options.should == { :user => "tommy@test.com", :password => "secret" }
     end
   
     it "PUT" do
@@ -46,7 +46,7 @@ describe BigBench::Fragment do
       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" }
+      fragments.first.options.should == { :book => "A Book" }
     end
   
     it "DELETE" do
@@ -54,7 +54,7 @@ describe BigBench::Fragment do
       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" }
+      fragments.first.options.should == { :user => "tommy@test.com", :password => "secret" }
     end
   
   end
@@ -64,45 +64,207 @@ describe BigBench::Fragment 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"
+      
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+
       @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"
+      
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+      
       @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"
+      
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+      
       @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"
+      
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+      
+      @benchmark.tracker.trackings.size.should == 1
+    end
+    
+  end
+  
+  context "should run basic auth fragments" do
+    
+    it "and track a 401 if no authorization was provided" do
+      fragment = BigBench::Fragment.parse(@benchmark){ get "/basic/auth" }.first
+      result = nil
+    
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 401
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+
+      @benchmark.tracker.trackings.size.should == 1
+      @benchmark.tracker.trackings.first[:status] == 401
+    end
+    
+    it "and work with fragment authorization" do
+      fragment = BigBench::Fragment.parse(@benchmark){
+        get "/basic/auth", :basic_auth => ['admin', 'secret']
+      }.first
+      result = nil
+    
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+
+      @benchmark.tracker.trackings.size.should == 1
+      @benchmark.tracker.trackings.first[:status] == 200
+    end
+    
+    it "and work with config authorization" do
+      BigBench.config.basic_auth = ['admin', 'secret']
+      fragment = BigBench::Fragment.parse(@benchmark){
+        get "/basic/auth"
+      }.first
+      result = nil
+    
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+
+      @benchmark.tracker.trackings.size.should == 1
+      @benchmark.tracker.trackings.first[:status] == 200
+    end
+  end
+  
+  context "should send params in body" do
+    
+    it "and track a 406 if no params were provided" do
+      fragment = BigBench::Fragment.parse(@benchmark){ post "/post/content" }.first
+      result = nil
+    
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 406
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+
+      @benchmark.tracker.trackings.size.should == 1
+      @benchmark.tracker.trackings.first[:status] == 406
+    end
+    
+    it "and work with params supplied" do
+      fragment = BigBench::Fragment.parse(@benchmark){
+        post "/post/content", :params => { :name => "bigbench", :id => 1 }
+      }.first
+      result = nil
+    
+      EventMachine.run { |http|
+        start = Time.now
+        http = fragment.run!
+
+        http.callback {
+          fragment.track!(start, Time.now, http)
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+
       @benchmark.tracker.trackings.size.should == 1
+      @benchmark.tracker.trackings.first[:status] == 200
     end
     
   end

data/spec/helpers.rb

@@ -2,16 +2,14 @@ require 'bigbench'
 require 'rack'
 require 'active_support/all'
 require 'net/http'
-require 'thin'
-require 'lib/test_web_server'
+require 'eventmachine'
+require 'em-http'
 
 module Helpers  
 end
 
 RSpec.configure do |config|
   config.include Helpers
-  config.before(:all) { TestWebServer.start }
-  config.after(:all)  { TestWebServer.stop }
   config.before(:each) { 
     BigBench::Configuration.reset!
     BigBench::Benchmark.reset!

data/spec/lib/test_web_server.rb

@@ -1,18 +1,47 @@
-module TestWebServer
-  mattr_accessor :server
-       
-  def self.start
-    TestWebServer.server = Thread.new {
-      app = proc { [200, {'Content-Type' => 'text/plain'}, ['Test']] }
-      Rack::Handler::Thin.run(app,:Port => 3001)
-    }
-    puts "Starting Test Webserver"
-    sleep 2
+require 'rubygems'
+require 'sinatra'
+
+set :port, 3001
+
+helpers do
+  def protected!
+    unless authorized?
+      response['WWW-Authenticate'] = %(Basic realm="BigBench TestWebServer")
+      throw(:halt, [401, "Not authorized\n"])
+    end
   end
-  
-  def self.stop
-    Thread.kill(TestWebServer.server)
-    puts "Stopping Test Webserver"
+
+  def authorized?
+    @auth ||=  Rack::Auth::Basic::Request.new(request.env)
+    @auth.provided? && @auth.basic? && @auth.credentials && @auth.credentials == ['admin', 'secret']
   end
-  
+end
+
+# Base HTTP Verbs
+get "/" do
+  "Test"
+end
+
+put "/" do
+  "Test"
+end
+
+post "/" do
+  "Test"
+end
+
+delete "/" do
+  "Test"
+end
+
+# Basic Auth URL
+get "/basic/auth" do
+  protected!
+  "Test"
+end
+
+# Needs Body Params
+post "/post/content" do
+  status 406 unless params[:name] == "bigbench" and params[:id] == "1"
+  "Test"
 end

data/spec/looper_spec.rb

@@ -0,0 +1,47 @@
+require_relative "./helpers"
+
+describe BigBench::Benchmark::Looper do
+  
+  before(:each) do
+    @benchmark = BigBench::Benchmark::Benchmark.new("a test benchmark", "http://localhost:3001", {}) do
+      get "/"
+      get "/logout"
+    end
+    @benchmark.start = Time.now
+  end
+  
+  it "should get the next fragment" do
+    looper = BigBench::Benchmark::Looper.new(@benchmark)
+    looper.next_fragment.path.should == "/"
+    looper.next_fragment.path.should == "/logout"
+    looper.next_fragment.path.should == "/"
+    looper.next_fragment.path.should == "/logout"
+    looper.next_fragment.path.should == "/"
+    looper.next_fragment.path.should == "/logout"
+  end
+  
+  it "should do nothing if benchmark is not running" do
+    looper = BigBench::Benchmark::Looper.new(@benchmark)
+    looper.loop!
+    
+    looper.loops.should == 0
+  end
+  
+  
+  it "should loop through the fragments as long as the benchmark is running" do
+    looper = BigBench::Benchmark::Looper.new(@benchmark)
+    
+    EventMachine.run {
+
+      timer = Thread.new{ sleep(5); @benchmark.is_running = false; EventMachine.stop }
+      @benchmark.is_running = true
+      @benchmark.start = Time.now
+      
+      looper.loop!
+    }
+    
+    looper.loops.should > 1000
+    @benchmark.tracker.trackings.size.should == looper.loops
+  end
+  
+end

data/spec/tests/local.rb

@@ -1,7 +1,7 @@
 BigBench.configure = {
   :duration => 1.seconds,
   :output   => "spec/temp/local.ljson",
-  :threads  => 1
+  :users  => 1
 }
 
 benchmark "index page" => "http://localhost:3001" do

data/spec/webserver_spec.rb

@@ -1,34 +1,104 @@
 require_relative "./helpers"
 
-describe TestWebServer do
+describe "TestWebServer" do
   
   it "should respond to mock GET requests" do    
-    uri = URI('http://localhost:3001/')
-    Net::HTTP.start(uri.host, uri.port) do |http|
-      request = Net::HTTP::Get.new(uri.request_uri)
-      last_response = http.request(request)
-      last_response.code.should == '200'
-      last_response.body.should == 'Test'
-    end
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://localhost:3001/').get
+
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Test/)
+        EventMachine.stop
+      }
+
+      http.errback { puts "Error"; EventMachine.stop }
+    }
   end
   
   it "should respond to mock POST requests" do
-    uri = URI('http://localhost:3001/')
-    Net::HTTP.start(uri.host, uri.port) do |http|
-      request = Net::HTTP::Post.new(uri.request_uri)
-      last_response = http.request(request)
-      last_response.code.should == '200'
-      last_response.body.should == 'Test'
-    end
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://localhost:3001/').put
+
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Test/)
+        EventMachine.stop
+      }
+
+      http.errback { puts "Error"; EventMachine.stop }
+    }
   end
   
   it "should respond to mock PUT requests" do
-    uri = URI('http://localhost:3001/')
-    Net::HTTP.start(uri.host, uri.port) do |http|
-      request = Net::HTTP::Put.new(uri.request_uri)
-      last_response = http.request(request)
-      last_response.code.should == '200'
-      last_response.body.should == 'Test'
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://localhost:3001/').post
+
+      http.callback {
+        http.response_header.status.should == 200
+        http.response.should match(/Test/)
+        EventMachine.stop
+      }
+
+      http.errback { puts "Error"; EventMachine.stop }
+    }
+  end
+  
+  context "should need basic auth" do
+    it "and fail without basic auth credentials" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://localhost:3001/basic/auth').get
+
+        http.callback {
+          http.response_header.status.should == 401
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+    end
+    
+    it "and work with basic auth supplied" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://localhost:3001/basic/auth').get :head => {'authorization' => ['admin', 'secret']}
+
+        http.callback {
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+    end
+  end
+  
+  context "should need a body" do
+    it "and fail without the right params set" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://localhost:3001/post/content').post
+
+        http.callback {
+          http.response_header.status.should == 406
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
+    end
+    
+    it "and work with params set" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://localhost:3001/post/content').post :body => { :name => "bigbench", :id => 1 }
+
+        http.callback {
+          http.response_header.status.should == 200
+          http.response.should match(/Test/)
+          EventMachine.stop
+        }
+
+        http.errback { puts "Error"; EventMachine.stop }
+      }
     end
   end