jperkins-deep_test 1.2.2

data/lib/deep_test/worker.rb

@@ -0,0 +1,57 @@
+module DeepTest
+  class Worker
+    attr_reader :number
+
+    def initialize(number, blackboard, worker_listener)
+      @number = number
+      @blackboard = blackboard
+      @listener = worker_listener
+    end
+
+    def run
+      @listener.starting(self)
+      while work_unit = next_work_unit
+        @listener.starting_work(self, work_unit)
+
+        result = begin
+                   work_unit.run
+                 rescue Exception => error
+                   Error.new(work_unit, error)
+                 end
+
+        @listener.finished_work(self, work_unit, result)
+        @blackboard.write_result result
+        if ENV['DEEP_TEST_SHOW_WORKER_DOTS'] == 'yes'
+          $stdout.print '.'
+          $stdout.flush
+        end
+      end
+    rescue Server::NoWorkUnitsRemainingError
+      DeepTest.logger.debug("Worker #{number}: no more work to do")
+    end
+
+    def next_work_unit
+      @blackboard.take_work
+    rescue Server::NoWorkUnitsAvailableError
+      sleep 0.02
+      retry
+    end
+
+    class Error
+      attr_accessor :work_unit, :error
+
+      def initialize(work_unit, error)
+        @work_unit, @error = work_unit, error
+      end
+
+      def ==(other)
+        work_unit == other.work_unit &&
+            error == other.error
+      end
+
+      def to_s
+        "#{@work_unit}: #{@error}\n" + (@error.backtrace || []).join("\n")
+      end
+    end
+  end
+end

data/script/internal/run_test_suite.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + "/../../lib/deep_test"
+options = DeepTest::Options.from_command_line(ARGV[0])
+DeepTest.init(options)
+runner = DeepTest::Test::Runner.new(options)
+workers = options.new_workers
+workers.load_files Dir.glob(options.pattern)
+DeepTest::ProcessOrchestrator.run(options, workers, runner)

data/script/public/master_test_server.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/../../lib/deep_test"
+require 'drb/drb'
+require 'optparse'
+
+uri = "drubyall://:4021"
+slave_uris = OptionParser.new do |opts|
+  opts.banner = "Usage: deep_test master_test_server [options] <test_server_uris>"
+
+  opts.on("--uri URI", "DRb URI to bind server to") do |v|
+    uri = v
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse(ARGV)
+
+begin
+  DeepTest::Distributed::MasterTestServer.start(uri, slave_uris)
+rescue Interrupt
+  DeepTest.logger.info "Exiting due to Interrupt"
+end
+

data/script/public/test_server.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + "/../../lib/deep_test"
+require 'drb/drb'
+require 'optparse'
+
+config = DeepTest::Distributed::TestServer.parse_args(ARGV)
+
+#
+# Clear args so they won't be processed in any forked processes.
+#    - When specs are loaded by the RemoteWorkerServer, RSpec
+#      attempts to parse ARGV
+#
+ARGV.clear
+
+begin
+  DeepTest::Distributed::TestServer.start(config)
+rescue Interrupt
+  DeepTest.logger.info "Exiting due to Interrupt"
+end

data/script/public/test_throughput.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../lib/deep_test'
+
+unless ARGV.length == 2
+  puts "Usage: deep_test test_throughput <server uri> <test_count>"
+  exit(1)
+end
+
+uri        = ARGV[0]
+test_count = ARGV[1].to_i
+
+options = DeepTest::Options.new(:distributed_server => uri,
+                                :sync_options => {:source => ""})
+server  = DeepTest::Distributed::TestServer.connect options
+workers = DeepTest::Distributed::ThroughputWorkerClient.new(options, server)
+runner  = DeepTest::Distributed::ThroughputRunner.new(options, test_count) do |result|
+  $stdout.print "."
+  $stdout.flush
+end
+
+start_time = Time.now
+DeepTest::ProcessOrchestrator.new(options, workers, runner).run(false)
+end_time = Time.now
+
+puts
+puts runner.statistics.summary
+
+run_time = end_time.to_f - start_time.to_f
+puts "Total Run Time: #{run_time} seconds"
+puts "Run Time Not Spent On Tests: #{run_time - runner.statistics.timespan_in_seconds}"

data/spec/deep_test/option_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module DeepTest
+  describe Option do
+    it "should have hash conversion" do
+      option = Option.new(:name, Option::Hash, {})
+      string = option.to_command_line({:a => "1", :b => "a"})
+      string.should be_instance_of(String)
+      option.from_command_line(string).should == {:a => "1", :b => "a"}
+    end
+
+    it "should support booleans in hash" do
+      option = Option.new(:name, Option::Hash, {})
+      string = option.to_command_line({:a => true})
+      string.should be_instance_of(String)
+      option.from_command_line(string).should == {:a => true}
+    end
+
+    it "should handle hash values with spaces" do
+      option = Option.new(:name, Option::Hash, {})
+
+      string = option.to_command_line(
+        {:a => "has a space", :b => "has more spaces"}
+      )
+
+      string.should be_instance_of(String)
+
+      option.from_command_line(string).should == 
+        {:a => "has a space", :b => "has more spaces"}
+    end
+  end
+end
+

data/spec/deep_test/options_spec.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module DeepTest
+  describe Options do
+    it "should support number_of_workers" do
+      Options.new(:number_of_workers => 3).number_of_workers.should == 3
+    end
+
+    it "should have reasonable defaults" do
+      options = Options.new({})
+      options.number_of_workers.should == 2
+      options.timeout_in_seconds.should == 30
+      options.server_port.should == 6969
+      options.pattern.should == nil
+      options.metrics_file.should == nil
+    end
+
+    it "should support timeout_in_seconds" do
+      Options.new(:timeout_in_seconds => 2).timeout_in_seconds.should == 2
+    end
+
+    it "should support pattern" do
+      Options.new(:pattern => '*').pattern.should == '*'
+    end
+
+    it "should support distributed_server" do
+      Options.new(:distributed_server => "uri").distributed_server.should == "uri"
+    end
+
+    it "should support server_port" do
+      Options.new(:server_port => 10).server_port.should == 10
+    end
+
+    it "should support sync_options" do
+      Options.new(:sync_options => {:options => 1}).sync_options.should == {:options => 1}
+    end
+
+    it "should support worker_listener" do
+      Options.new(:worker_listener => "AListener").
+        worker_listener.should == "AListener"
+    end
+
+    it "should use DeepTest::NullWorkerListener as the default listener" do
+      Options.new({}).worker_listener.should == "DeepTest::NullWorkerListener"
+    end
+    
+    it "should allow worker_listener to be set with class" do
+      class FakeListener; end
+      Options.new(:worker_listener => FakeListener).
+        worker_listener.should == "DeepTest::FakeListener"
+    end
+
+    it "should allow multiple workers to be specified" do
+      class FakeListener1; end
+      class FakeListener2; end
+      options = Options.new(
+        :worker_listener => "DeepTest::FakeListener1,DeepTest::FakeListener2"
+      )
+      listener = options.new_listener_list
+      listener.should be_instance_of(DeepTest::ListenerList)
+      listener.listeners.should have(2).listeners
+      listener.listeners.first.should be_instance_of(FakeListener1)
+      listener.listeners.last.should be_instance_of(FakeListener2)
+    end
+
+    it "should create a list of worker listeners upon request" do
+      Options.new({}).new_listener_list.should be_instance_of(DeepTest::ListenerList)
+    end
+
+    it "should support ui" do
+      Options.new(:ui => "AUI").ui.should == "AUI"
+    end
+
+    it "should use DeepTest:UIas the default listener" do
+      Options.new({}).ui.should == "DeepTest::UI::Console"
+    end
+    
+    it "should allow ui to be set with class" do
+      class FakeUI; end
+      Options.new(:ui => FakeUI).ui.should == "DeepTest::FakeUI"
+    end
+
+    it "should instantiate ui, passing itself as parameter" do
+      options = Options.new({})
+      DeepTest::UI::Console.should_receive(:new).with(options)
+      options.ui_instance
+    end
+
+    it "should instantiate ui only one" do
+      options = Options.new({})
+      options.ui_instance.should equal(options.ui_instance)
+    end
+
+    it "should support strings as well as symbols" do
+      Options.new("number_of_workers" => 2).number_of_workers.should == 2
+    end
+
+    it "should raise error when invalid option is specifed" do
+      lambda {
+        Options.new(:foo => 1)
+      }.should raise_error(Options::InvalidOptionError)
+    end
+
+    it "should convert to command line option string" do
+      options = Options.new(:number_of_workers => 1, :timeout_in_seconds => 3)
+      options.to_command_line.should == 
+        "--number_of_workers 1 --timeout_in_seconds 3"
+    end
+
+    it "should parse from command line option string" do
+      options = Options.from_command_line( 
+        "--number_of_workers 2 --timeout_in_seconds 3 --pattern *")
+      options.number_of_workers.should == 2
+      options.timeout_in_seconds.should == 3
+      options.pattern.should == '*'
+    end
+
+    it "should use default option value when no command line option is present" do
+      options = Options.from_command_line("")
+      options.number_of_workers.should == 2
+    end
+
+    it "should create local workers by default" do
+      options = Options.new({})
+      options.new_workers.should be_instance_of(LocalWorkers) 
+    end
+
+    it "should create remote worker client when distributed server is specified" do
+      options = Options.new(:distributed_server => "uri", :sync_options => {:source => "root"})
+      Distributed::TestServer.should_receive(:connect).with(options).and_return(:server_instance)
+      Distributed::RemoteWorkerClient.should_receive(:new).with(options, :server_instance, be_instance_of(LocalWorkers))
+      options.new_workers
+    end
+
+    it "should create local workers when connect fails" do
+      options = Options.new(:distributed_server => "uri", :sync_options => {:source => "root"}, :ui => "DeepTest::UI::Null")
+      Distributed::TestServer.should_receive(:connect).and_raise("An error")
+      options.new_workers.should be_instance_of(LocalWorkers) 
+    end
+
+    it "should return localhost as origin_hostname current hostname is same as when created" do
+      options = Options.new({})
+      options.origin_hostname.should == 'localhost'
+    end
+
+    it "should hostname at instantiation when current hostname is different" do
+      local_hostname = Socket.gethostname
+      options = Options.new({})
+      Socket.should_receive(:gethostname).and_return("host_of_query")
+      options.origin_hostname.should == local_hostname
+    end
+
+    it "should be able to calculate mirror_path based on base an sync_options" do
+      Socket.should_receive(:gethostname).and_return("hostname", "server_hostname")
+      options = Options.new(:sync_options => {:source => "/my/source/path"})
+      options.mirror_path("/mirror/base/path").should == 
+        "/mirror/base/path/hostname_my_source_path"
+    end
+
+    it "should raise a useful error if no source is specified" do
+      options = DeepTest::Options.new(:sync_options => {})
+      lambda {
+        options.mirror_path("base")
+      }.should raise_error("No source directory specified in sync_options")
+    end
+
+    it "should create drb object to connect to server" do
+      options = DeepTest::Options.new({})
+      server = options.server
+      server.__drburi.should == "druby://#{options.origin_hostname}:#{options.server_port}"
+    end
+
+    it "should be gathering metrics if metrics file is set" do
+      options = DeepTest::Options.new(:metrics_file => "filename")
+      options.should be_gathering_metrics
+    end
+
+    it "should not be gathering metrics if metrics file is not set" do
+      options = DeepTest::Options.new({})
+      options.should_not be_gathering_metrics
+    end
+  end
+end

data/spec/deep_test/spec/extensions/example_group_methods_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+module Spec
+  module Example
+    # NoMethodError: undefined method `subclass' if constant is used below
+    # instead of string
+    describe "ExampleGroupMethods" do
+      before(:each) do
+        $show_deep_test_all_block_warning = true
+      end
+
+      it_should_behave_like "sandboxed rspec_options"
+      
+      [:append_before, :before, :after, :prepend_before, :append_after, :prepend_after].each do |rspec_method|
+        it "should print warning on first call to #{rspec_method}(:all)" do
+          out = capture_stderr do
+            describe("test") do
+              send(rspec_method, :all) {}
+              send(rspec_method, :all) {}
+            end
+          end
+
+          out.should == ExampleGroupMethods::DeepTestAllBlockWarning + "\n"
+        end
+
+        it "#{rspec_method}(:all) should not print warning if global setting is turned off" do
+          $show_deep_test_all_block_warning = false
+          
+          out = capture_stderr do
+            describe("test") do
+              send(rspec_method, :all) {}
+            end
+          end
+
+          out.should == ""
+        end
+        
+        it "should not raise error on #{rspec_method}(:each)" do
+          lambda {
+            describe("test") do
+              send(rspec_method, :each) {}
+            end
+          }.should_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/deep_test/spec/extensions/example_methods_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+module Spec
+  module Example
+    describe ExampleMethods do
+      it_should_behave_like "sandboxed rspec_options"
+
+      it "should have identifier that can locate the example by line" do
+        group = describe("test") do
+          it("example") {}
+          it("example") {}
+        end
+
+        example_1 = group.examples.first
+        example_2 = group.examples.last
+
+        example_1.identifier.locate([group]).should == example_1
+        example_2.identifier.locate([group]).should == example_2
+      end
+
+      it "should have identifier that can locate the example by name" do
+        group = describe("test") do
+          2.times do |i|
+            it("example#{i}") {}
+          end
+        end
+
+        example_1 = group.examples.first
+        example_2 = group.examples.last
+
+        example_1.identifier.locate([group]).should == example_1
+        example_2.identifier.locate([group]).should == example_2
+      end
+
+      describe ExampleMethods::Identifier do
+        it "should use descriptions in to_s" do
+          group = describe("test") do
+            it("example") {}
+          end
+
+          group.examples.first.identifier.to_s.should == "test example"
+        end
+
+        it "should be equal if basenames of paths are equal" do
+          id1 = ExampleMethods::Identifier.new("/a/spec.rb",
+                                               10,
+                                               "group description",
+                                               "description")
+                                               
+          id2 = ExampleMethods::Identifier.new("/b/spec.rb",
+                                               10,
+                                               "group description",
+                                               "description")
+
+          id1.should == id2
+        end
+      end
+    end
+  end
+end
+