jstorimer-deep-test 1.4.0 → 2.0.0

data/test/deep_test/distributed/dispatch_controller_test.rb

@@ -1,209 +1,162 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-unit_tests do
-  test "dispatch invokes each receiver once" do
-    receiver_1, receiver_2 = mock, mock
+module DeepTest
+  module Distributed
+    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]
-    )
+        controller = DispatchController.new(
+          Options.new({:ui => "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
-
-  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
+        controller.dispatch(:a_method, :args)
+      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
+      test "dispatch returns array of all results" do
+        receiver_1, receiver_2 = mock, mock
 
-    receiver_2.expects(:method_call_1)
-    receiver_2.expects(:method_call_2)
+        controller = DispatchController.new(
+          Options.new({:ui => "UI::Null"}), 
+          [receiver_1, receiver_2]
+        )
 
-    controller = DeepTest::Distributed::DispatchController.new(
-      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
-      [receiver_1, receiver_2]
-    )
+        receiver_1.expects(:a_method).returns(:result_1)
+        receiver_2.expects(:a_method).returns(:result_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
+        results = controller.dispatch(:a_method)
+        assert_equal 2, results.size
+        assert_equal [:result_1, :result_2].to_set, results.to_set
+      end
 
-    receiver_2.expects(:method_call_1).returns(:value)
-    receiver_2.expects(:method_call_2)
+      test "dispatch calls all receivers in parallel" do
+        options = Options.new({:ui => "UI::Null"})
+        waiter = Waiter.new(tracker = Tracker.new)
 
-    controller = DeepTest::Distributed::DispatchController.new(
-      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
-      [receiver_1, receiver_2]
-    )
+        Timeout.timeout(1) do
+          DispatchController.new(options,[tracker, waiter]).
+            dispatch(:tracked_method)
+        end
 
-    DeepTest.logger.expects(:error)
-    
-    assert_equal [:value], controller.dispatch(:method_call_1)
+        waiter = Waiter.new(tracker = Tracker.new)
 
-    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
+        Timeout.timeout(1) do
+          DispatchController.new(options,[waiter, tracker]).
+            dispatch(:tracked_method)
+        end
+      end
 
-  test "no error is printed if dispatching without error" do
-    receiver_1 =  mock
-    receiver_1.expects(:method_call_1).raises(DRb::DRbConnError)
+      test "receiver is dropped when any exception occurs" do
+        receiver = mock
+        receiver.expects(:method_call).raises(Exception)
 
-    controller = DeepTest::Distributed::DispatchController.new(
-      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
-      [receiver_1]
-    )
+        controller = DispatchController.new(
+          Options.new({:ui => "UI::Null"}),
+          [receiver]
+        )
 
-    DeepTest.logger.expects(:error).never
+        controller.dispatch(:method_call)
+        assert_raises(NoDispatchReceiversError) {controller.dispatch(:another_call)}
+      end
 
-    controller.dispatch_with_options(:method_call_1, :ignore_connection_error => true)
-  end
+      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
 
-  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]
-    )
+      test "dispatch calls notifies ui of start and stop of dispatch" do
+        options = Options.new({:ui => "UI::Null"})
+        controller = 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
+        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 "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
 
-  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, []
-    )
+      test "error is raised if dispatch to no receivers in attempted" do
+        options = Options.new({:ui => "UI::Null"})
+        controller = DispatchController.new(
+          options, []
+        )
 
-    assert_raises(DeepTest::Distributed::NoDispatchReceiversError) do
-      controller.dispatch(:any_method)
-    end
-  end
+        assert_raises(NoDispatchReceiversError) do
+          controller.dispatch(:any_method)
+        end
+      end
 
-  class Tracker
-    def initialize
-      @mutex = Mutex.new
-      @condvar = ConditionVariable.new
-    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 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)
+        def wait_for_tracked_method
+          @mutex.synchronize do
+            loop do
+              return if @tracked_method_called
+              @condvar.wait(@mutex)
+            end
+          end
         end
       end
-    end
-  end
 
-  class Waiter
-    def initialize(tracker)
-      @tracker = tracker
-    end
+      class Waiter
+        def initialize(tracker)
+          @tracker = tracker
+        end
 
-    def tracked_method
-      @tracker.wait_for_tracked_method
+        def tracked_method
+          @tracker.wait_for_tracked_method
+        end
+      end
     end
   end
 end

data/test/deep_test/distributed/filename_resolver_test.rb

@@ -1,52 +1,56 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-unit_tests do
-  test "should strip off directories until file exists in base path" do
-    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "should strip off directories until file exists in base path" do
+        resolver = FilenameResolver.new("base_path")
 
-    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
-    File.expects(:exist?).with("base_path/b/c/d.rb").returns(false)
-    File.expects(:exist?).with("base_path/c/d.rb").returns(true)
+        File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
+        File.expects(:exist?).with("base_path/b/c/d.rb").returns(false)
+        File.expects(:exist?).with("base_path/c/d.rb").returns(true)
 
-    assert_equal "base_path/c/d.rb", resolver.resolve("/a/b/c/d.rb")
-  end
+        assert_equal "base_path/c/d.rb", resolver.resolve("/a/b/c/d.rb")
+      end
 
-  test "should resolve relative names starting at first element" do
-    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+      test "should resolve relative names starting at first element" do
+        resolver = FilenameResolver.new("base_path")
 
-    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(true)
+        File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(true)
 
-    assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
-  end
+        assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
+      end
 
-  test "should resolve relative names the same each time" do
-    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+      test "should resolve relative names the same each time" do
+        resolver = FilenameResolver.new("base_path")
 
-    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(true)
+        File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(true)
 
-    assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
-    assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
-  end
+        assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
+        assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
+      end
 
-  test "should raise exception if filename can't be resolved" do
-    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+      test "should raise exception if filename can't be resolved" do
+        resolver = FilenameResolver.new("base_path")
 
-    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
-    File.expects(:exist?).with("base_path/b/c/d.rb").returns(false)
-    File.expects(:exist?).with("base_path/c/d.rb").returns(false)
-    File.expects(:exist?).with("base_path/d.rb").returns(false)
+        File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
+        File.expects(:exist?).with("base_path/b/c/d.rb").returns(false)
+        File.expects(:exist?).with("base_path/c/d.rb").returns(false)
+        File.expects(:exist?).with("base_path/d.rb").returns(false)
 
-    assert_raises(RuntimeError) { resolver.resolve("/a/b/c/d.rb") }
-  end
+        assert_raises(RuntimeError) { resolver.resolve("/a/b/c/d.rb") }
+      end
 
-  test "should remember how many directories to strip off after first resolution" do
-    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+      test "should remember how many directories to strip off after first resolution" do
+        resolver = FilenameResolver.new("base_path")
 
-    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
-    File.expects(:exist?).with("base_path/b/c/d.rb").returns(true)
-    
-    resolver.resolve("/a/b/c/d.rb")
+        File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
+        File.expects(:exist?).with("base_path/b/c/d.rb").returns(true)
+        
+        resolver.resolve("/a/b/c/d.rb")
 
-    assert_equal "base_path/x/y/z.rb", resolver.resolve("/a/x/y/z.rb")
+        assert_equal "base_path/x/y/z.rb", resolver.resolve("/a/x/y/z.rb")
+      end
+    end
   end
 end

data/test/deep_test/distributed/landing_fleet_test.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "push_code is invoked on all servers" do
+        server_1, server_2 = mock, mock
+        options = Options.new({:ui => "UI::Null"})
+
+        fleet = LandingFleet.new(options, [server_1, server_2])
+
+        server_1.expects(:push_code).with(options)
+        server_2.expects(:push_code).with(options)
+
+        fleet.push_code(options)
+      end
+
+      test "establish_beachhead is invoked on all server" do
+        server_1, server_2 = mock, mock
+        options = Options.new({:ui => "UI::Null"})
+
+        fleet = LandingFleet.new(options, [server_1, server_2])
+
+        server_1.expects(:establish_beachhead).with(options)
+        server_2.expects(:establish_beachhead).with(options)
+
+        fleet.establish_beachhead(options)
+      end
+
+      test "load_files is invoked on all server" do
+        server_1, server_2 = mock, mock
+        options = Options.new({:ui => "UI::Null"})
+
+        fleet = LandingFleet.new(options, [server_1, server_2])
+
+        server_1.expects(:load_files).with(['a'])
+        server_2.expects(:load_files).with(['a'])
+
+        fleet.load_files(['a'])
+      end
+
+      test "deploy_agents is invoked on all server" do
+        server_1, server_2 = mock, mock
+        options = Options.new({:ui => "UI::Null"})
+
+        fleet = LandingFleet.new(options, [server_1, server_2])
+
+        server_1.expects(:deploy_agents)
+        server_2.expects(:deploy_agents)
+
+        fleet.deploy_agents
+      end
+    end
+  end
+end