jstorimer-deep-test 0.2.0 → 1.0.0

data/spec/spec_helper.rb

@@ -1,9 +1,11 @@
 require 'rubygems'
-gem('rspec', ENV['RSPEC_VERSION'] || '1.1.12')
+gem 'rspec', '=1.1.8'
 require 'spec'
 
-require File.dirname(__FILE__) + '/../lib/deep_test'
-require File.dirname(__FILE__) + "/../infrastructure/load"
+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
@@ -15,18 +17,8 @@ describe "sandboxed rspec_options", :shared => true do
     ::Spec::Runner.use @options
   end
 
-  after(:each) { ::Spec::Runner.use @original_rspec_options }
-
-  before(:each) { DynamicTeardown.setup }
-  after(:each) { DynamicTeardown.teardown }
-
-  before(:each) do
-    @old_logger = DeepTest.logger
-    DeepTest.logger = TestLogger.new
-  end
-
   after(:each) do
-    DeepTest.logger = @old_logger if @old_logger
+    ::Spec::Runner.use @original_rspec_options
   end
 
   class FakeReporter

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

@@ -1,18 +1,14 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-module DeepTest
-  module Database
-    unit_tests do
-      test "dump_schema includes procedures" do
-        listener = 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
+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

@@ -1,162 +1,209 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-module DeepTest
-  module Distributed
-    unit_tests do
-      test "dispatch invokes each receiver once" do
-        receiver_1, receiver_2 = mock, mock
+unit_tests do
+  test "dispatch invokes each receiver once" do
+    receiver_1, receiver_2 = mock, mock
 
-        controller = DispatchController.new(
-          Options.new({:ui => "UI::Null"}), 
-          [receiver_1, receiver_2]
-        )
+    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)
+    receiver_1.expects(:a_method).with(:args)
+    receiver_2.expects(:a_method).with(:args)
 
-        controller.dispatch(:a_method, :args)
-      end
+    controller.dispatch(:a_method, :args)
+  end
 
-      test "dispatch returns array of all results" do
-        receiver_1, receiver_2 = mock, mock
+  test "dispatch returns array of all results" do
+    receiver_1, receiver_2 = mock, mock
 
-        controller = DispatchController.new(
-          Options.new({:ui => "UI::Null"}), 
-          [receiver_1, receiver_2]
-        )
+    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)
+    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
+    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 = Options.new({:ui => "UI::Null"})
-        waiter = Waiter.new(tracker = Tracker.new)
+  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
-          DispatchController.new(options,[tracker, waiter]).
-            dispatch(:tracked_method)
-        end
+    Timeout.timeout(1) do
+      DeepTest::Distributed::DispatchController.new(options,[tracker, waiter]).
+        dispatch(:tracked_method)
+    end
 
-        waiter = Waiter.new(tracker = Tracker.new)
+    waiter = Waiter.new(tracker = Tracker.new)
 
-        Timeout.timeout(1) do
-          DispatchController.new(options,[waiter, tracker]).
-            dispatch(:tracked_method)
-        end
-      end
+    Timeout.timeout(1) do
+      DeepTest::Distributed::DispatchController.new(options,[waiter, tracker]).
+        dispatch(:tracked_method)
+    end
+  end
 
-      test "receiver is dropped when any exception occurs" do
-        receiver = mock
-        receiver.expects(:method_call).raises(Exception)
+  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 = DispatchController.new(
-          Options.new({:ui => "UI::Null"}),
-          [receiver]
-        )
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver]
+    )
 
-        controller.dispatch(:method_call)
-        assert_raises(NoDispatchReceiversError) {controller.dispatch(:another_call)}
-      end
+    DeepTest.logger.expects(:error)
 
-      test "error is printed with backtrace when it occurrs" do
-        e = Exception.new("message")
-        e.set_backtrace %w[file1:1 file2:2]
-        receiver = mock
-        receiver.expects(:method_call).raises(e)
-
-        controller = DispatchController.new(
-          Options.new({:ui => "UI::Null"}),
-          [receiver]
-        )
-
-        Timewarp.freeze("2009-09-22 12:01:33") do
-          controller.dispatch(:method_call)
-          assert_equal <<-end_log, DeepTest.logger.logged_output
-[DeepTest@#{Socket.gethostname}] 2009-09-22 12:01:33 Exception while dispatching method_call to #{receiver.inspect}:
-[DeepTest@#{Socket.gethostname}] 2009-09-22 12:01:33 Exception: message
-[DeepTest@#{Socket.gethostname}] 2009-09-22 12:01:33 file1:1
-[DeepTest@#{Socket.gethostname}] 2009-09-22 12:01:33 file2:2
-          end_log
-        end
-      end
+    assert_equal [], controller.dispatch(:sleep_100_millis)
+  end
 
-      test "dispatch calls notifies ui of start and stop of dispatch" do
-        options = Options.new({:ui => "UI::Null"})
-        controller = DispatchController.new(
-          options, [stub_everything]
-        )
+  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
 
-        options.ui_instance.expects(:dispatch_starting).with(:method_name)
-        options.ui_instance.expects(:dispatch_finished).with(:method_name)
-        
-        controller.dispatch(:method_name)
-      end
+    receiver_2.expects(:method_call_1)
+    receiver_2.expects(:method_call_2)
 
-      test "dispatch calls notifies ui dispatch end in case of an error" do
-        options = Options.new({:ui => "UI::Null"})
-        controller = DispatchController.new(
-          options, [receiver = mock]
-        )
-        receiver.expects(:method_name).raises("An 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
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1, receiver_2]
+    )
 
-      test "error is raised if dispatch to no receivers in attempted" do
-        options = Options.new({:ui => "UI::Null"})
-        controller = DispatchController.new(
-          options, []
-        )
+    DeepTest.logger.expects(:error)
+    
+    controller.dispatch(:method_call_1)
+    controller.dispatch(:method_call_2)
+  end
 
-        assert_raises(NoDispatchReceiversError) do
-          controller.dispatch(:any_method)
-        end
-      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
 
-      class Tracker
-        def initialize
-          @mutex = Mutex.new
-          @condvar = ConditionVariable.new
-        end
+    receiver_2.expects(:method_call_1).returns(:value)
+    receiver_2.expects(:method_call_2)
 
-        def tracked_method 
-          @mutex.synchronize do
-            @tracked_method_called = true
-            @condvar.broadcast
-          end
-        end
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1, receiver_2]
+    )
 
-        def wait_for_tracked_method
-          @mutex.synchronize do
-            loop do
-              return if @tracked_method_called
-              @condvar.wait(@mutex)
-            end
-          end
-        end
-      end
+    DeepTest.logger.expects(:error)
+    
+    assert_equal [:value], controller.dispatch(:method_call_1)
 
-      class Waiter
-        def initialize(tracker)
-          @tracker = tracker
-        end
+    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, []
+    )
 
-        def tracked_method
-          @tracker.wait_for_tracked_method
+    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

data/test/deep_test/distributed/drb_client_connection_info_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "returns ipaddress from peeraddr as address" do
+    info = Thread.current['DRb']
+    begin
+      Thread.current['DRb'] = {
+        'client' => mock(:peeraddr => [nil, nil, nil, "ip"])
+      }
+
+      info = DeepTest::Distributed::DRbClientConnectionInfo.new
+    ensure
+      Thread.current['DRb'] = info
+    end
+
+    assert_equal "ip", info.address
+  end
+
+  test "raises an error if no drb client is found" do
+    info = Thread.current['DRb']
+    begin
+      Thread.current['DRb'] = {}
+      assert_raises(RuntimeError) do
+        DeepTest::Distributed::DRbClientConnectionInfo.new
+      end
+    ensure
+      Thread.current['DRb'] = info
+    end
+  end
+
+  test "raises an error if no drb info is found" do
+    info = Thread.current['DRb']
+    begin
+      Thread.current['DRb'] = nil
+      assert_raises(RuntimeError) do
+        DeepTest::Distributed::DRbClientConnectionInfo.new
+      end
+    ensure
+      Thread.current['DRb'] = info
+    end
+  end
+end