jperkins-deep_test 1.2.2

data/spec/deep_test/spec/extensions/options_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+describe Spec::Runner::Options do
+  it_should_behave_like "sandboxed rspec_options"
+
+  it "should be able to run a single passing example" do
+    example_group = describe("test") do
+      it("passes") {1.should == 1}
+      it("fails") {1.should == 2} 
+    end
+    options.run_one_example(example_group.examples.first.identifier)
+    options.reporter.passed?.should == true
+  end 
+
+  it "should be able to run a single failing example" do
+    example_group = describe("test") do
+      it("passes") {1.should == 1}
+      it("fails") {1.should == 2}
+    end
+    options.run_one_example(example_group.examples.last.identifier)
+    options.reporter.passed?.should == false
+  end 
+end

data/spec/deep_test/spec/extensions/reporter_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+describe Spec::Runner::Reporter do
+  it_should_behave_like "sandboxed rspec_options"
+
+  it "should be able to handle a failure without having any example groups" do
+    example_group = describe("test") do
+      it("example") {}
+    end
+    example = example_group.examples.first
+    reporter = Spec::Runner::Reporter.new(options)
+    lambda {
+      reporter.failure(example,RuntimeError.new)
+    }.should_not raise_error
+  end
+
+  it "should be able to handle a pending example without having any example groups" do
+    example_group = describe("test") do
+      it("example") {pending}
+    end
+    example = example_group.examples.first
+    reporter = Spec::Runner::Reporter.new(options)
+    lambda {
+      reporter.example_finished(example,::Spec::Example::ExamplePendingError.new)
+    }.should_not raise_error
+  end
+end
+

data/spec/deep_test/spec/extensions/spec_task_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/../../../spec_helper"
+
+describe Spec::Rake::SpecTask do
+  it "should allow deep_test configuration" do
+    t = Spec::Rake::SpecTask.new do |t|
+      t.deep_test :number_of_workers => 2
+    end
+
+    deep_test_path = File.expand_path(File.dirname(__FILE__) + 
+                                      '/../../../../lib/deep_test')
+    options = DeepTest::Options.new(:number_of_workers => 2)
+    t.spec_opts.should == ["--require #{deep_test_path}",
+                           "--runner 'DeepTest::Spec::Runner:#{options.to_command_line}'"]
+  end
+
+  it "should maintain deep_test options if spec_opts is set directly" do
+    t = Spec::Rake::SpecTask.new do |t|
+      t.deep_test({})
+      t.spec_opts = ["anoption"]
+    end
+
+    deep_test_path = File.expand_path(File.dirname(__FILE__) + 
+                                      '/../../../../lib/deep_test')
+    options = DeepTest::Options.new({})
+    t.spec_opts.should == ["--require #{deep_test_path}",
+                           "--runner 'DeepTest::Spec::Runner:#{options.to_command_line}'",
+                           "anoption"]
+  end
+
+  it "should allow spec_opts to be set without deep_test" do
+    t = Spec::Rake::SpecTask.new do |t|
+      t.spec_opts = ["anoption"]
+    end
+    t.spec_opts.should == ["anoption"]
+  end
+end

data/spec/deep_test/spec/runner_spec.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+module DeepTest
+  module Spec
+    describe Runner do
+      it_should_behave_like 'sandboxed rspec_options'
+
+      it "should run each test using blackboard" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
+
+        describe("test") do
+          it("passes1") {}
+          it("passes2") {}
+        end
+
+        worker = ThreadWorker.new(blackboard, 2)
+        Timeout.timeout(5) do
+          runner.process_work_units.should == true
+        end
+        worker.wait_until_done
+
+        worker.work_done.should == 2
+        options.reporter.number_of_examples.should == 2
+        blackboard.take_result.should be_nil
+        options.reporter.examples_finished.should == ['passes1','passes2']
+        options.reporter.should be_ended
+      end
+
+      it "should return failure when a spec fails" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
+
+        describe("test") do
+          it("passes") {}; 
+          it("fails") {1.should == 2}; 
+        end
+
+        worker = ThreadWorker.new(blackboard, 2)
+        Timeout.timeout(5) do
+          runner.process_work_units.should == false
+        end
+        worker.wait_until_done
+      end
+
+      it "should return success when there are pending examples" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
+
+        describe("test") do
+          it("pending") {pending {1.should == 2}}; 
+        end
+
+        worker = ThreadWorker.new(blackboard, 1)
+        Timeout.timeout(5) do
+          runner.process_work_units.should == true
+        end
+        worker.wait_until_done
+      end
+
+      it "should return failure when a pending example passes" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
+
+        describe("test") do
+          it("pending") {pending {1.should == 1}}; 
+        end
+
+        worker = ThreadWorker.new(blackboard, 1)
+        Timeout.timeout(5) do
+          runner.process_work_units.should == false
+        end
+        worker.wait_until_done
+      end
+
+      it "should return failure when a worker error occurs" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
+
+        describe("test") do
+          it("pending") {pending {1.should == 1}}; 
+        end
+
+        blackboard.write_result Worker::Error.new("example", RuntimeError.new)
+        capture_stdout do
+          runner.process_work_units.should == false
+        end
+
+        options.reporter.number_of_errors.should == 1
+      end
+
+      it "should raise error if duplicate spec is found" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
+
+        describe("test") do
+          2.times {it("example") {}}; 
+        end
+
+        lambda {
+          runner.process_work_units
+        }.should raise_error
+      end
+    end
+  end
+end

data/spec/deep_test/spec/work_result_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe DeepTest::Spec::WorkResult do
+  it "should make errors marshallable" do
+    result = DeepTest::Spec::WorkResult.new("id", Exception.new, nil)
+    result.instance_variable_get(:@error).should be_instance_of(DeepTest::MarshallableExceptionWrapper)
+    result.error.should be_instance_of(Exception)
+  end
+
+  it "should preserve nil errors" do
+    result = DeepTest::Spec::WorkResult.new("id", nil, nil)
+    result.error.should be_nil
+  end
+end

data/spec/deep_test/spec/work_unit_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe DeepTest::Spec::WorkUnit do
+  it_should_behave_like "sandboxed rspec_options"
+
+  it "should run the example specified by location" do
+    spec_was_run = false
+    group = describe("test") do
+      it("passes") {spec_was_run = true}
+    end
+    work_unit = DeepTest::Spec::WorkUnit.new(group.examples.first.identifier)
+    work_unit.run
+    spec_was_run.should == true
+  end
+
+  it "should return a Spec::WorkResult with the location and errors" do
+    error = RuntimeError.new
+    group = describe("test") do
+      it("fails") {raise error}
+    end
+    id = group.examples.first.identifier
+    work_unit = DeepTest::Spec::WorkUnit.new(id)
+    work_unit.run.should == DeepTest::Spec::WorkResult.new(id, error, nil)
+  end
+
+  it "should preserve the original rspec_options reporter" do
+    group = describe("test") do
+      it("passes") {}
+    end
+    original_reporter = options.reporter
+    work_unit = DeepTest::Spec::WorkUnit.new(group.examples.first.identifier)
+    work_unit.run
+    options.reporter.should == original_reporter
+  end
+
+  it "should retry examples that fail due to deadlock once" do
+    example_run_count = 0
+    group = describe("test") do
+      it("passes") {example_run_count += 1; raise FakeDeadlockError.new if example_run_count == 1}; 
+    end
+    work_unit = DeepTest::Spec::WorkUnit.new(group.examples.first.identifier)
+    result = work_unit.run
+    example_run_count.should == 2
+    result.error.should == nil
+  end
+
+  it "should move on without failing test if example fails do to deadlock more than once" do
+    example_run_count = 0
+    group = describe("test") do
+      it("passes") {example_run_count += 1; raise FakeDeadlockError.new}; 
+    end
+    work_unit = DeepTest::Spec::WorkUnit.new(group.examples.first.identifier)
+    result = work_unit.run
+    example_run_count.should == 2
+    result.error.should == nil
+    result.output.should == '-deadlock-'
+  end
+
+  it "should only run examples that don't fail due to deadlock once" do
+    example_run_count = 0
+    group = describe("test") do
+      it("passes") {example_run_count += 1; raise "Error"}
+    end
+    work_unit = DeepTest::Spec::WorkUnit.new(group.examples.first.identifier)
+    result = work_unit.run
+    example_run_count.should == 1
+    result.error.message.should == "Error"
+  end
+
+  it "should provide useful description as string" do
+    group = describe("my example") do
+      it("passes") {}
+    end
+    work_unit = DeepTest::Spec::WorkUnit.new(group.examples.first.identifier)
+
+    work_unit.to_s.should == "my example: passes"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+gem 'rspec', '=1.1.8'
+require 'spec'
+
+require File.dirname(__FILE__) + "/../lib/deep_test"
+require File.dirname(__FILE__) + "/../test/fake_deadlock_error"
+require File.dirname(__FILE__) + "/../test/simple_test_blackboard"
+require File.dirname(__FILE__) + "/thread_worker"
+
+describe "sandboxed rspec_options", :shared => true do
+  attr_reader :options
+
+  before(:each) do
+    @original_rspec_options = ::Spec::Runner.options
+    @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+    @options.reporter = FakeReporter.new
+    ::Spec::Runner.use @options
+  end
+
+  after(:each) do
+    ::Spec::Runner.use @original_rspec_options
+  end
+
+  class FakeReporter
+    attr_reader :number_of_examples, :examples_finished, :number_of_errors
+
+    def initialize
+      @examples_finished = []
+      @number_of_errors = 0
+    end
+
+    def example_started(example) end
+    def add_example_group(example_group) end
+
+    def end
+      @ended = true
+    end
+
+    def ended?
+      @ended == true
+    end
+
+    def dump; end
+
+    def start(number_of_examples) 
+      @number_of_examples = number_of_examples
+    end
+
+    def example_finished(example, error)
+      @examples_finished << example.description
+      @number_of_errors += 1 if error
+      @error = error
+    end
+
+    def passed?
+      @error == nil
+    end
+  end
+end

data/spec/thread_worker.rb

@@ -0,0 +1,25 @@
+class ThreadWorker
+  attr_reader :work_done
+
+  def initialize(blackboard, expected_work)
+    @blackboard, @expected_work = blackboard, expected_work
+    @thread = Thread.new {run}
+  end
+
+  def wait_until_done
+    Timeout.timeout(5) {@thread.join}
+    @thread.kill if @thread.alive?
+  end
+
+  def run
+    @work_done = 0
+    until @work_done >= @expected_work
+      Thread.pass
+      work = @blackboard.take_work
+      if work
+        @blackboard.write_result work.run 
+        @work_done += 1
+      end
+    end
+  end
+end

data/test/deep_test/database/mysql_setup_listener_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "dump_schema includes procedures" do
+    listener = DeepTest::Database::MysqlSetupListener.new
+    listener.expects(:system).with do |command|
+      command =~ / -R /
+    end
+    listener.expects(:master_database_config).returns({})
+    listener.expects(:dump_file_name).returns("")
+    $?.expects(:success?).returns(true)
+    listener.dump_schema
+  end
+end

data/test/deep_test/distributed/dispatch_controller_test.rb

@@ -0,0 +1,209 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "dispatch invokes each receiver once" do
+    receiver_1, receiver_2 = mock, mock
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}), 
+      [receiver_1, receiver_2]
+    )
+
+    receiver_1.expects(:a_method).with(:args)
+    receiver_2.expects(:a_method).with(:args)
+
+    controller.dispatch(:a_method, :args)
+  end
+
+  test "dispatch returns array of all results" do
+    receiver_1, receiver_2 = mock, mock
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}), 
+      [receiver_1, receiver_2]
+    )
+
+    receiver_1.expects(:a_method).returns(:result_1)
+    receiver_2.expects(:a_method).returns(:result_2)
+
+    results = controller.dispatch(:a_method)
+    assert_equal 2, results.size
+    assert_equal [:result_1, :result_2].to_set, results.to_set
+  end
+
+  test "dispatch calls all receivers in parallel" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    waiter = Waiter.new(tracker = Tracker.new)
+
+    Timeout.timeout(1) do
+      DeepTest::Distributed::DispatchController.new(options,[tracker, waiter]).
+        dispatch(:tracked_method)
+    end
+
+    waiter = Waiter.new(tracker = Tracker.new)
+
+    Timeout.timeout(1) do
+      DeepTest::Distributed::DispatchController.new(options,[waiter, tracker]).
+        dispatch(:tracked_method)
+    end
+  end
+
+  test "dispatch omits results that are taking too long" do
+    receiver = Object.new
+    def receiver.__drburi; ""; end
+    def receiver.sleep_100_millis
+      sleep 0.1
+    end
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver]
+    )
+
+    DeepTest.logger.expects(:error)
+
+    assert_equal [], controller.dispatch(:sleep_100_millis)
+  end
+
+  test "after timeout, no further calls are sent to that receiver" do
+    receiver_1, receiver_2 = mock(:__drburi => ""), mock
+    receiver_1.expects(:method_call_1).raises(Timeout::Error.new("message"))
+    receiver_1.expects(:method_call_2).never
+
+    receiver_2.expects(:method_call_1)
+    receiver_2.expects(:method_call_2)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1, receiver_2]
+    )
+
+    DeepTest.logger.expects(:error)
+    
+    controller.dispatch(:method_call_1)
+    controller.dispatch(:method_call_2)
+  end
+
+  test "receiver is dropped when connection is refused" do
+    receiver_1, receiver_2 = mock(:__drburi => ""), mock
+    receiver_1.expects(:method_call_1).raises(DRb::DRbConnError)
+    receiver_1.expects(:method_call_2).never
+
+    receiver_2.expects(:method_call_1).returns(:value)
+    receiver_2.expects(:method_call_2)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1, receiver_2]
+    )
+
+    DeepTest.logger.expects(:error)
+    
+    assert_equal [:value], controller.dispatch(:method_call_1)
+
+    controller.dispatch(:method_call_2)
+  end
+  
+  test "receiver is dropped when any exception occurs" do
+    receiver = mock(:__drburi => "")
+    receiver.expects(:method_call).raises(Exception)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver]
+    )
+
+    DeepTest.logger.expects(:error)
+    
+    controller.dispatch(:method_call)
+    assert_raises(DeepTest::Distributed::NoDispatchReceiversError) {controller.dispatch(:another_call)}
+  end
+
+  test "no error is printed if dispatching without error" do
+    receiver_1 =  mock
+    receiver_1.expects(:method_call_1).raises(DRb::DRbConnError)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1]
+    )
+
+    DeepTest.logger.expects(:error).never
+
+    controller.dispatch_with_options(:method_call_1, :ignore_connection_error => true)
+  end
+
+  test "dispatch calls notifies ui of start and stop of dispatch" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    controller = DeepTest::Distributed::DispatchController.new(
+      options, [stub_everything]
+    )
+
+    options.ui_instance.expects(:dispatch_starting).with(:method_name)
+    options.ui_instance.expects(:dispatch_finished).with(:method_name)
+    
+    controller.dispatch(:method_name)
+  end
+
+  test "dispatch calls notifies ui dispatch end in case of an error" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    controller = DeepTest::Distributed::DispatchController.new(
+      options, [receiver = mock(:__drburi => '')]
+    )
+    receiver.expects(:method_name).raises("An Error")
+    DeepTest.logger.expects(:error)
+    
+    options.ui_instance.expects(:dispatch_starting).with(:method_name)
+    options.ui_instance.expects(:dispatch_finished).with(:method_name)
+    
+    begin
+      controller.dispatch(:method_name)
+    rescue RuntimeError => e
+      raise unless e.message == "An Error"
+    end
+  end
+
+  test "error is raised if dispatch to no receivers in attempted" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    controller = DeepTest::Distributed::DispatchController.new(
+      options, []
+    )
+
+    assert_raises(DeepTest::Distributed::NoDispatchReceiversError) do
+      controller.dispatch(:any_method)
+    end
+  end
+
+  class Tracker
+    def initialize
+      @mutex = Mutex.new
+      @condvar = ConditionVariable.new
+    end
+
+    def tracked_method 
+      @mutex.synchronize do
+        @tracked_method_called = true
+        @condvar.broadcast
+      end
+    end
+
+    def wait_for_tracked_method
+      @mutex.synchronize do
+        loop do
+          return if @tracked_method_called
+          @condvar.wait(@mutex)
+        end
+      end
+    end
+  end
+
+  class Waiter
+    def initialize(tracker)
+      @tracker = tracker
+    end
+
+    def tracked_method
+      @tracker.wait_for_tracked_method
+    end
+  end
+end