bigbench 0.0.4 → 0.0.5

data/lib/bigbench/executor.rb

@@ -5,145 +5,115 @@ module BigBench
   # :include: executor.txt
   module Executor
     
-    COMMANDS = [
-      "--help", "show help",
-      "run local PATH_TO_TEST",
-      "run bots PATH_TO_TEST [REDIS_URL_WITH_PORT REDIS_PASSWORD]",
-      "start bot [REDIS_URL_WITH_PORT REDIS_PASSWORD]",
-      "reset all [REDIS_URL_WITH_PORT REDIS_PASSWORD]",
-      "run postprocessors PATH_TO_TEST",
-      "run postprocessor PATH_TO_TEST POSTPROCESSOR"
-      ]
-    
-    # Is thrown when the command is not known
-    class InvalidCommand < StandardError
-      def message
-        puts "\n\n"
-        puts "Sorry, could not compile your command. Please enter one of the following commands:\n\n"
-        COMMANDS.each{ |command| puts command }
-        puts " "
-        
-        "Sorry, could not compile your command."
-      end
-    end
-    
-    # Parses and runs the BigBench funtion that is supplied via the commandline's ARGV. It
-    # throws an <tt>InvalidCommand</tt> exception if the command is unknown.
-    def self.run!(argv)
-      BigBench::Output.start
+    class Executable < Thor
+      include Thor::Actions
       
-      check_arguments!(argv)
-      send to_executor_method(argv), argv
+      # Templates are here
+      def self.source_root
+        File.join(File.dirname(__FILE__), "templates")
+      end
       
-      BigBench::Output.done
-    end
-    
-    private
-    
-    # Maps the incoming ARGV to a method
-    def self.to_executor_method(argv)
-      return "show_help" if argv.first == "--help"
-      "#{argv[0]}_#{argv[1]}".to_sym
-    end
-    
-    # Checks if the supplied ARGV has a valid and useable form
-    def self.check_arguments!(argv)
-      raise InvalidCommand.new if argv.nil? or argv.empty?
-      raise InvalidCommand.new unless respond_to?(to_executor_method(argv))
-      true
-    end
-    
-    # Runs a local test with the specified test.rb. For this mode no redis is needed.
-    def self.run_local(argv)
-      BigBench.load_test! File.open(argv[2], "rb"){ |file| file.read }
-      BigBench.run!
-      BigBench.write_local_trackings_to_file!
-      BigBench.run_post_processors!
-    end
-    
-    # Runs a test on all available bots with the specified test.rb
-    #
-    #    bigbench run bots test.rb http://localhost:6379 password
-    #
-    def self.run_bots(argv)
+      # Version and Help
+      desc "-v", "Show the version"
+      method_options %w( version -v ) => :boolean
+      def default
+        options.version? ? puts(BigBench::VERSION) : help
+      end
+      default_task :default
       
-      # Load and validate tests
-      test = File.open(argv[2], "rb"){ |file| file.read }
-      BigBench.load_test!(test)
-      BigBench.config.mode = :bots
+      # Run Local
+      desc "local TEST_FILE", "Run the TEST_FILE on the local machine"
+      def local(file)
+        BigBench.load_test! File.open(file, "rb"){ |file| file.read }
+        BigBench.run!
+        BigBench.write_local_trackings_to_file!
+        BigBench.run_post_processors!
+      end
       
-      # Initialize redis
-      argv.shift(3)
-      BigBench::Store.setup!(*argv)
+      # Run Bots
+      desc "bots TEST_FILE [REDIS_URL_WITH_PORT] [REDIS_PASSWORD]", "Run the TEST_FILE on all bots"
+      def bots(file, redis_url = nil, redis_password = nil)
+        
+        # Load and validate tests
+        test = File.open(file, "rb"){ |file| file.read }
+        BigBench.load_test!(test)
+        BigBench.config.mode = :bots
+
+        # Initialize redis
+        BigBench::Store.setup!(redis_url, redis_password)
+
+        # Load current test to redis & start bots
+        BigBench::Store.test = test
+        BigBench::Store.start
+        BigBench::Output.deployed_test
+
+        # Wait for bots to run the tests
+        @is_running = true
+        timer = Thread.new{
+          sleep(BigBench.duration.to_i)
+          BigBench::Store.stop
+          @is_running = false
+        }
+
+        BigBench::Output.starting_bots_loop
+        loop{
+          bots = BigBench::Store.bots
+          BigBench::Output.running_bots_loop(bots)
+          sleep(1)
+          break if !@is_running and bots.size == 0
+        }
+
+        # Gather trackings from redis and write them to the file
+        BigBench::Output.finished_bots_loop
+        BigBench.write_store_trackings_to_file!
+        BigBench.run_post_processors!
+        BigBench::Store.reset!
+      end
       
-      # Load current test to redis & start bots
-      BigBench::Store.test = test
-      BigBench::Store.start
-      BigBench::Output.deployed_test
+      # Start Bot
+      desc "bot [REDIS_URL_WITH_PORT] [REDIS_PASSWORD]", "Start a bot on the current machine"
+      def bot(redis_url = nil, redis_password = nil)
+        BigBench::Store.setup!(redis_url, redis_password)
+
+        loop {
+          BigBench::Output.bot_is_checking
+          BigBench::Bot.check_test!
+          sleep(BigBench.config.bot_checks_every.to_i)
+        }
+      end
       
-      # Wait for bots to run the tests
-      @is_running = true
-      timer = Thread.new{
-        sleep(BigBench.duration.to_i)
-        BigBench::Store.stop
-        @is_running = false
-      }
+      # Post Process
+      desc "process TEST_FILE [POST_PROCESSOR]", "Run all post processors of the testfile or the single POST_PROCESSOR"
+      def process(file, post_processor = nil)
+        BigBench.load_test! File.open(file, "rb"){ |file| file.read }
+        
+        if post_processor
+          BigBench::PostProcessor.reset!
+          BigBench.post_process(post_processor)
+          BigBench.run_post_processors!
+        else
+          BigBench.run_post_processors!
+        end
+      end
       
-      BigBench::Output.starting_bots_loop
-      loop{
-        bots = BigBench::Store.bots
-        BigBench::Output.running_bots_loop(bots)
-        sleep(1)
-        break if !@is_running and bots.size == 0
-      }
+      # Reset
+      desc "reset [REDIS_URL_WITH_PORT] [REDIS_PASSWORD]", "Reset everything including the redis storage"
+      def reset(redis_url = nil, redis_password = nil)
+        BigBench::Store.setup!(redis_url, redis_password)
+        BigBench::Store.reset!
+        BigBench::Configuration.reset!
+        BigBench::Benchmark.reset!
+        BigBench::Output.reset
+      end
       
-      # Gather trackings from redis and write them to the file
-      BigBench::Output.finished_bots_loop
-      BigBench.write_store_trackings_to_file!
-      BigBench.run_post_processors!
-      BigBench::Store.reset!
-    end
-    
-    # Starts the bot that listens for tests on the redis
-    def self.start_bot(argv)
-      argv.shift(2)
-      BigBench::Store.setup!(*argv)
+      # Generator
+      desc "generate TEST_FILE", "Generates a simple test file to customize further"
+      def generate(name)
+        @name = name
+        template "test_plan.rb.erb", "#{name}.rb"
+      end
       
-      loop {
-        BigBench::Output.bot_is_checking
-        BigBench::Bot.check_test!
-        sleep(BigBench.config.bot_checks_every.to_i)
-      }
-    end
-    
-    # Shows the command line help
-    def self.show_help(argv)
-      File.open("lib/bigbench/help/executor.txt", "rb"){ |file| file.read }
-    end
-    
-    # Resets everything
-    def self.reset_all(argv)
-      argv.shift(2)
-      BigBench::Store.setup!(*argv)
-      BigBench::Store.reset!
-      BigBench::Configuration.reset!
-      BigBench::Benchmark.reset!
-      BigBench::Output.reset
-    end
-    
-    # Re-runs all receipt defined post processors
-    def self.run_postprocessors(argv)
-      BigBench.load_test! File.open(argv[2], "rb"){ |file| file.read }
-      BigBench.run_post_processors!
     end
-    
-    # Runs a new postprocessor for receipt
-    def self.run_postprocessor(argv)
-      BigBench.load_test! File.open(argv[2], "rb"){ |file| file.read }
-      BigBench::PostProcessor.reset!
-      BigBench.post_process(argv[3])
-      BigBench.run_post_processors!
-    end
-    
+        
   end
 end

data/lib/bigbench/help/executor.txt

@@ -1,22 +1,9 @@
-Usage:
-  # Local Testing
-  bigbench run local PATH_TO_TEST                                       # Runs a test from the local machine. No redis needed.
-
-  # Remote Testing
-  bigbench run bots PATH_TO_TEST [REDIS_URL_WITH_PORT REDIS_PASSWORD]   # Deploys and starts the test on all bots
-  bigbench start bot [REDIS_URL_WITH_PORT REDIS_PASSWORD]               # Starts a bot on a remote machine
-  
-  # Reseting
-  bigbench reset all                                                    # Resets everything
-  
-  # Post Processors
-  bigbench run postprocessors PATH_TO_TEST                              # Runs all post processors of the test without running the test itself
-  bigbench run postprocessor PATH_TO_TEST POSTPROCESSOR                 # Runs the specified post processor on the output file
-
-  # Help
-  bigbench --help || show help                                          # Displays this help
-
-Options:
-  REDIS_URL_WITH_PORT   # Defaults to http://localhost:6379
-  REDIS_PASSWORD        # Defaults to no password
-  POSTPROCESSOR         # A post processor module or its short name e.g. 'statistics'
+Tasks:
+  bigbench -v                                                     # Show the version
+  bigbench bot [REDIS_URL_WITH_PORT] [REDIS_PASSWORD]             # Start a bot on the current machine
+  bigbench bots TEST_FILE [REDIS_URL_WITH_PORT] [REDIS_PASSWORD]  # Run the TEST_FILE on all bots
+  bigbench generate TEST_FILE                                     # Generates a simple test file to customize further
+  bigbench help [TASK]                                            # Describe available tasks or one specific task
+  bigbench local TEST_FILE                                        # Run the TEST_FILE on the local machine
+  bigbench process TEST_FILE [POST_PROCESSOR]                     # Run all post processors of the testfile or the single POST_PROCESSOR
+  bigbench reset [REDIS_URL_WITH_PORT] [REDIS_PASSWORD]           # Reset everything including the redis storage

data/lib/bigbench/output.rb

@@ -102,13 +102,12 @@ module BigBench
     end
     
     def self.bot_is_checking
-      puts "Checking for new tests at #{Time.now}"
+      puts "#{Time.now}: Checking for new test plan"
       $stdout.flush
     end
     
     def self.bot_received_test_instructions
-      puts "\n-> Received\n"
-      puts "Received test instructions\n"
+      puts "#{Time.now}: Received new test plan"
       $stdout.flush
     end
     

data/lib/bigbench/post_processor.rb

@@ -75,7 +75,7 @@ module BigBench
       # Run the block of code or the run! method of the processor
       def run!
         @runs += 1
-        PostProcessor::Environment.module_exec(@options, &@proc)
+        Context.module_exec(@options, &@proc)
       end
       
       private
@@ -94,9 +94,13 @@ module BigBench
       
       def processor_to_module(processor)
         return processor if processor.is_a? Module
-        mod = "BigBench::PostProcessor::#{processor.to_s.camelize}"
-        require mod.underscore.sub('big_bench', 'bigbench')
-        mod.constantize
+        
+        module_name = "BigBench::PostProcessor::#{processor.to_s.camelize}"
+        module_constant = module_name.constantize
+        return module_constant if module_constant.is_a? Module
+        
+        require module_name.underscore.sub('big_bench', 'bigbench')
+        module_constant
       end
     end
     
@@ -116,6 +120,14 @@ module BigBench
       Environment.reset!
     end
     
+    # The context in which post processor procs are evaluated
+    module Context
+      class << self
+        include Environment
+        include ActionView::Helpers
+      end
+    end
+    
     # Thrown if a processor wasn't initialized the right way
     class InvalidProcessor < StandardError
       def message

data/lib/bigbench/runner.rb

@@ -46,7 +46,6 @@ module BigBench
   def self.load_test!(test)
     BigBench::Benchmark.reset!
     eval(test)
-    check_config!
     BigBench::Output.loaded_tests
   end
   

data/lib/bigbench/store.rb

@@ -13,8 +13,8 @@ module BigBench
     
     # 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)
+    def self.setup!(url = nil, password = nil)
+      uri = URI(url || "localhost:6379")
       @redis = ::Redis.new :host => uri.host, :port => uri.port, :password => password
       true
     end

data/lib/bigbench/templates/test_plan.rb.erb

@@ -0,0 +1,17 @@
+BigBench.configure do |config|
+  config.duration = 2.minutes
+  config.output   = "<%= @name %>.ljson"
+  config.users    = 10
+end
+
+# benchmark "index page" => "http://localhost:3000" do
+#   get "/"
+#   get "/posts"
+#   post "/posts", :params => { :title => "A new Post", :body => "This is some fancy text" }
+# end
+#
+# benchmark "managing posts" => "http://localhost:3000" do
+#   post "/posts", :params => { :title => "A new Post", :body => "This is some fancy text" }
+# end
+
+post_process :statistics

data/lib/bigbench/version.rb

@@ -1,3 +1,3 @@
 module BigBench
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/configure_spec.rb

@@ -4,11 +4,11 @@ describe BigBench::Configuration do
   
   it "should store the config values" do
     
-    BigBench.configure = {
-      :duration => 10.seconds,
-      :output   => "test.ljson",
-      :users    => 20
-    }
+    BigBench.configure do |config|
+      config.duration = 10.seconds
+      config.output   = "test.ljson"
+      config.users    = 20
+    end
     
     BigBench.config.duration.should == 10.seconds
     BigBench.config.output.should == "test.ljson"
@@ -21,19 +21,8 @@ describe BigBench::Configuration do
     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",
-      :users    => 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")
+  it "should raise an exception if no configure block is specified" do
+    lambda {BigBench.configure}.should raise_error
   end
   
 end

data/spec/executor_spec.rb

@@ -2,34 +2,14 @@ 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
-    
+  before(:each) do
+    Dir.chdir File.dirname(__FILE__)
   end
   
   it "should run a local test with trackings" do    
     
-    argv = ["run", "local", "spec/tests/local.rb"]
-    BigBench::Executor.run!(argv)
+    argv = ["local", "tests/local.rb"]
+    BigBench::Executor::Executable.start(argv)
     
     BigBench.benchmarks.size.should == 2
     BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 1 }
@@ -45,8 +25,8 @@ describe BigBench::Executor do
   
   it "should run a bot test" do
     
-    argv = ["run", "bots", "spec/tests/local.rb"]
-    BigBench::Executor.run!(argv)
+    argv = ["bots", "tests/local.rb"]
+    BigBench::Executor::Executable.start(argv)
     
     BigBench.benchmarks.size.should == 2
     BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 0 }
@@ -61,17 +41,17 @@ describe BigBench::Executor do
   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
+    argv = ["help"]
+    lambda{ BigBench::Executor::Executable.start(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)
+    argv = ["reset"]
+    BigBench::Executor::Executable.start(argv)
     
     BigBench.benchmarks.size.should == 0
     BigBench::Store.test.should be_nil
@@ -79,8 +59,8 @@ describe BigBench::Executor do
   
   it "should re-run the post processors from a receipt" do
     
-    argv = ["run", "postprocessors", "spec/tests/with_post_processor.rb"]
-    BigBench::Executor.run!(argv)
+    argv = ["process", "tests/with_post_processor.rb"]
+    BigBench::Executor::Executable.start(argv)
     
     BigBench.benchmarks.size.should == 1
     BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 0 }
@@ -96,8 +76,8 @@ describe BigBench::Executor do
   
   it "should run a single post processor for a single test" do
     
-    argv = ["run", "postprocessor", "spec/tests/with_post_processor.rb", "statistics"]
-    BigBench::Executor.run!(argv)
+    argv = ["process", "tests/with_post_processor.rb", "statistics"]
+    BigBench::Executor::Executable.start(argv)
     
     BigBench.benchmarks.size.should == 1
     BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 0 }
@@ -112,4 +92,14 @@ describe BigBench::Executor do
     
   end
   
+  it "should generate a new testfile", :generate do
+    Dir.chdir "tmp"
+    
+    File.exists?("new_test.rb").should be_false
+    argv = ["generate", "new_test"]
+    BigBench::Executor::Executable.start(argv)
+    File.exists?("new_test.rb").should be_true
+    FileUtils.rm "new_test.rb"
+  end
+  
 end