abcrunch 0.0.4

data/spec/lib/ab_result_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe "AbCrunch::AbResult" do
+  def new_abr(raw_ab_output, ab_options = {})
+    AbCrunch::AbResult.new(raw_ab_output, ab_options)
+  end
+
+  describe "#initialize" do
+    it "should remember the provided raw ab output and options" do
+      abr = new_abr('foo', {:foo => 'bar'})
+      abr.raw.should == 'foo'
+      abr.ab_options.should == {:foo => 'bar'}
+    end
+  end
+
+  describe "#command" do
+    it "should return the ab command used to produce the result" do
+      ab_options = {:crunch => 'now'}
+      mock(AbCrunch::AbRunner).ab_command(ab_options) { 'tight!' }
+      abr = new_abr('blah', ab_options)
+      abr.command.should == 'tight!'
+    end
+  end
+
+  describe "#avg_response_time" do
+    it "should glean the average response time from raw ab output and return as a float" do
+      abr = new_abr("fleeblesnork\nTime per request:       43.028 [ms] (mean)\n\nblah")
+      abr.avg_response_time.should == 43.028
+    end
+
+    describe "when the raw value is an integer" do
+      it "should still be returned as a float" do
+        abr = new_abr("fleeblesnork\nTime per request:       43 [ms] (mean)\n\nblah")
+        abr.avg_response_time.should == 43.0
+        abr.avg_response_time.class.to_s.should == 'Float'
+      end
+    end
+  end
+
+  describe "#queries_per_second" do
+    it "should glean the queries per second from raw ab output and return as a float" do
+      abr = new_abr("fleeblesnork\nRequests per second:    162.68 [#/sec] (mean)\n\nblah")
+      abr.queries_per_second.should == 162.68
+    end
+
+    describe "when the raw value is an integer" do
+      it "should still be returned as a float" do
+        abr = new_abr("fleeblesnork\nRequests per second:    162 [#/sec] (mean)\n\nblah")
+        abr.queries_per_second.should == 162.0
+        abr.queries_per_second.class.to_s.should == 'Float'
+      end
+    end
+  end
+
+  describe "#failed_requests" do
+    it "should glean the failed request count from raw ab output and return as a fixnum" do
+      abr = new_abr("fleeblesnork\nFailed requests:        17\n\nblah")
+      abr.failed_requests.should == 17
+      abr.failed_requests.class.to_s.should == 'Fixnum'
+    end
+  end
+
+  describe "#log" do
+    it "should log command, avg response time,  queries per second, and failed requests" do
+      ab_options = {:crunch => 'now'}
+      abr = new_abr('blah', ab_options)
+      mock(abr).command { 'tight!' }
+      mock(abr).avg_response_time { "186" }
+      mock(abr).queries_per_second { "50" }
+      mock(abr).failed_requests { '10' }
+      #  ...
+      lines = []
+      stub(AbCrunch::Logger).log { |*args|
+        args[0].should == :ab_result
+        lines << args[1]
+      }
+      abr.log
+      lines.should == [
+        'tight!',
+        'Average Response Time: 186',
+        'Queries per Second: 50',
+        'Failed requests: 10'
+      ]
+    end
+  end
+
+end

data/spec/lib/ab_runner_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "AbRunner" do
+  describe "#validate_options" do
+    it "should throw an error when no url is provided" do
+      lambda {
+        AbCrunch::AbRunner.validate_options({})
+      }.should raise_error "AB Options missing :url"
+    end
+
+    it "should return the options merged into the global configuration's ab_options'" do
+      result = AbCrunch::AbRunner.validate_options({:url => 'some url'})
+      result.should == AbCrunch::Config.ab_options.merge({:url => 'some url'})
+    end
+  end
+
+  describe "#ab_command" do
+    it "should return the ab command line based on given options, forcing the page url to reset" do
+      options = {
+        :concurrency => 'thigh master',
+        :num_requests => 'i can only do 5 today',
+        :url => '5 minute abs'
+      }
+      mock.proxy(AbCrunch::Page).get_url(options, true)
+
+      AbCrunch::AbRunner.ab_command(options).should == "ab -c thigh master -n i can only do 5 today -k -H 'Accept-Encoding: gzip' 5 minute abs"
+    end
+  end
+
+  describe "#ab" do
+    it "should run ab and wrap the results in an ab result" do
+      def Open3.block=(block) ; @block = block ; end
+      def Open3.block(cmd, &block)
+        self.block = block if block_given?
+        block.call(StringIO.new(''), StringIO.new('some fake output'), StringIO.new(''))
+        return(@block)
+      end
+      Open3.block = nil
+      stub(Open3).popen3.implemented_by(Open3.method(:block))
+
+      stub(AbCrunch::AbRunner).ab_command('bar') { 'foo' }
+      mock(AbCrunch::AbResult).new('some fake output', 'bar') { 'six pack' }
+      
+      AbCrunch::AbRunner.ab('bar').should == 'six pack'
+    end
+  end
+end

data/spec/lib/best_run_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "BestRun" do
+  before :all do
+    @ab_options = {
+      :url => 'foo',
+      :concurrency => 1,
+      :num_requests => 10
+    }
+  end
+
+  describe "#of_avg_response_time" do
+    it "should run ab on the ab options N times" do
+      stub(AbCrunch::Logger).log
+      num_runs = 0
+      stub(AbCrunch::AbRunner).ab(@ab_options) do
+        num_runs += 1
+        obj = "foo"
+
+        class << obj
+          def avg_response_time
+            4
+          end
+        end
+        obj
+      end
+
+      AbCrunch::BestRun.of_avg_response_time(7, @ab_options)
+
+      num_runs.should == 7
+    end
+
+    it "should return the ab result for the run with the lowest avg response time" do
+      stub(AbCrunch::Logger).log
+      response_times = [3, 87, 1, 590]
+
+      run_idx = 0
+      stub(AbCrunch::AbRunner).ab(@ab_options) do
+        obj = Object.new
+        response_time = response_times[run_idx]
+        obj.singleton_class.class_eval do
+          define_method(:avg_response_time) do
+            response_time
+          end
+        end
+
+        run_idx += 1
+        obj
+      end
+
+      result = AbCrunch::BestRun.of_avg_response_time(4, @ab_options)
+
+      result.avg_response_time.should == 1
+    end
+  end
+end

data/spec/lib/config_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "AbCrunch::Config" do
+  it "should have hashes for ab options and max concurrent options" do
+    AbCrunch::Config.best_concurrency_options.class.to_s.should == 'Hash'
+    AbCrunch::Config.ab_options.class.to_s.should == 'Hash'
+  end
+
+  it "should have a hash for the pages to be tested" do
+    AbCrunch::Config.page_sets.class.to_s.should == 'Hash'
+  end
+
+  describe "#page_sets=" do
+    it "should remember the new page sets and force new rake tasks to be created" do
+      mock(AbCrunch::Config).load(File.join(AbCrunch.root, "lib/abcrunch/tasks/generated.rake"))
+
+      AbCrunch::Config.page_sets = { :foo => 'bar' }
+
+      AbCrunch::Config.page_sets.should == { :foo => 'bar' }
+    end
+  end
+end

data/spec/lib/log_console_writer_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe "AbCrunch::LogConsoleWriter" do
+  describe "#color_for_type" do
+    it "should return the color for the given type" do
+      AbCrunch::LogConsoleWriter.color_for_type(:progress).should == :green
+    end
+
+    describe "when the type is unknown" do
+      it "should return white" do
+        AbCrunch::LogConsoleWriter.color_for_type(:weasel).should == :white
+      end
+    end
+  end
+
+  describe "#prefix_for_type" do
+    it "should return the prefix for the given type" do
+      AbCrunch::LogConsoleWriter.prefix_for_type(:progress).should == '  '
+    end
+
+    describe "when the type is unknown" do
+      it "should return an empty string" do
+        AbCrunch::LogConsoleWriter.prefix_for_type(:weasel).should == ''
+      end
+    end
+  end
+
+  describe "#log" do
+    describe "inline behavior" do
+      before :each do
+        @calls = []
+        @messages = []
+        stub(AbCrunch::LogConsoleWriter).print do |msg|
+          @calls << 'print'
+          @messages << msg
+        end
+        stub(AbCrunch::LogConsoleWriter).puts do |msg|
+          @calls << 'puts'
+          @messages << msg
+        end
+      end
+
+      describe "when the message is intended to be inline" do
+        it "should print instead of puts" do
+          AbCrunch::LogConsoleWriter.log(:info, 'foo', {:inline => true})
+
+          @calls.should == ['print']
+        end
+      end
+
+      describe "when the message is NOT intended to be inline" do
+        it "should puts instead of print" do
+          AbCrunch::LogConsoleWriter.log(:info, 'foo')
+
+          @calls.should == ['puts']
+        end
+      end
+
+      describe "when the previous message was inline, and the current one is not" do
+        it "should prepend a new line" do
+          AbCrunch::LogConsoleWriter.log(:info, 'foo', {:inline => true})
+          AbCrunch::LogConsoleWriter.log(:info, 'foo')
+
+          @messages[1].should include "\n  foo"
+        end
+      end
+    end
+
+    describe "if the type has a color" do
+      it "should should invoke the color on the message" do
+        calls = []
+        any_instance_of(String) do |s|
+          stub(s).green { calls << 'green' }
+        end
+
+        AbCrunch::LogConsoleWriter.log(:progress, 'foo')
+
+        calls.should == ['green']
+      end
+    end
+  end
+end

data/spec/lib/logger_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe "AbCrunch::Logger" do
+  describe "#log" do
+    it "should call log on all writers" do
+      AbCrunch::Logger.writers = [AbCrunch::LogConsoleWriter]
+      mock(AbCrunch::LogConsoleWriter).log(:foo, 'bar', {:bizz => 'bazam!'})
+
+      AbCrunch::Logger.log(:foo, 'bar', {:bizz => 'bazam!'})
+    end
+  end
+end

data/spec/lib/page_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "AbCrunch::Page" do
+  describe "#get_url" do
+    describe "when the page url is a string" do
+      it "should return the string" do
+        page = { :url => 'some url' }
+
+        AbCrunch::Page.get_url(page).should == 'some url'
+      end
+    end
+
+    describe "when the page url is a proc" do
+      it "should call the proc and return the result" do
+        page = { :url => Proc.new { 'a proc url' } }
+
+        AbCrunch::Page.get_url(page).should == 'a proc url'
+      end
+
+      describe "when the page url is a proc returning different results each call" do
+
+        before :each do
+          @call_num = 0
+          @page = { :url => Proc.new { @call_num += 1 ; "changing url #{@call_num}" } }
+        end
+
+        describe "when called repeatedly without force_new" do
+          it "should return the same url each time" do
+            AbCrunch::Page.get_url(@page).should == 'changing url 1'
+            AbCrunch::Page.get_url(@page).should == 'changing url 1'
+            AbCrunch::Page.get_url(@page).should == 'changing url 1'
+          end
+        end
+
+        describe "when called repeadedly with force_new = True" do
+          it "should return different urls each time" do
+            AbCrunch::Page.get_url(@page, true).should == 'changing url 1'
+            AbCrunch::Page.get_url(@page, true).should == 'changing url 2'
+            AbCrunch::Page.get_url(@page, true).should == 'changing url 3'
+          end
+        end
+      end
+    end
+
+  end
+
+  describe "#get_display_url" do
+    describe "when the url is a string" do
+      it "should return the string" do
+        page = { :url => 'a text url' }
+
+        AbCrunch::Page.get_display_url(page).should == 'a text url'
+      end
+    end
+
+    describe "when the url is a proc" do
+      it "should return an example, noting that it's dynamic'" do
+        page = { :url => Proc.new { 'a proc url' } }
+
+        AbCrunch::Page.get_display_url(page).should == 'Dynamic url example: a proc url'
+      end
+    end
+  end
+end

data/spec/lib/page_tester_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe "AbCrunch::PageTester" do
+  describe "#test" do
+
+    def stub_strategies(result = nil)
+      strategy_result = result ? result : AbCrunchSpec.new_result
+
+      @strategies.each do |strategy|
+        stub(strategy).run { strategy_result }
+      end
+    end
+
+    before :each do
+      @test_page = AbCrunchSpec.new_page
+      @test_result = AbCrunchSpec.new_result
+      @strategies = [AbCrunch::StrategyBestConcurrency]
+
+      stub(AbCrunch::Logger).log
+    end
+
+    it "should show the display url" do
+      stub_strategies
+
+      mock(AbCrunch::Page).get_display_url(@test_page)
+
+      AbCrunch::PageTester.test(@test_page)
+    end
+
+    it "should run every load testing strategy on the given page" do
+      @strategies.each do |strategy|
+        mock(strategy).run(@test_page) { @test_result }
+      end
+
+      AbCrunch::PageTester.test(@test_page)
+    end
+
+    it "should use any user provided max avg response time as the max latency for all strategies" do
+      stub_strategies
+      page = AbCrunchSpec.new_page({:max_avg_response_time => 139.2})
+
+      AbCrunch::PageTester.test(page)
+
+      page[:max_latency].should == 139.2
+    end
+
+    it "should fail if the avg response time is over the specified maximum" do
+      result = AbCrunchSpec.new_result
+      class << result
+        def avg_response_time
+          200
+        end
+      end
+      page = AbCrunchSpec.new_page({:max_avg_response_time => 117})
+
+      stub_strategies(result)
+
+      passed, qps_result, errors = AbCrunch::PageTester.test(page)
+
+      passed.should == false
+      errors.should == [
+        "some page: Avg response time of 200 must be <= 117"
+      ]
+    end
+
+    it "should fail if the queries per second is under the specified minimum" do
+      result = AbCrunchSpec.new_result
+      class << result
+        def queries_per_second
+          5
+        end
+      end
+      page = AbCrunchSpec.new_page({:min_queries_per_second => 117})
+
+      stub_strategies(result)
+
+      passed, qps_result, errors = AbCrunch::PageTester.test(page)
+
+      passed.should == false
+      errors.should == [
+        "some page: QPS of 5 must be >= 117"
+      ]
+    end
+  end
+end