deep_test_pre 2.0

data/test/deep_test/distributed/dispatch_controller_test.rb

@@ -0,0 +1,162 @@
+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
+
+        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)
+
+        controller.dispatch(:a_method, :args)
+      end
+
+      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]
+        )
+
+        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 = Options.new({:ui => "UI::Null"})
+        waiter = Waiter.new(tracker = Tracker.new)
+
+        Timeout.timeout(1) do
+          DispatchController.new(options,[tracker, waiter]).
+            dispatch(:tracked_method)
+        end
+
+        waiter = Waiter.new(tracker = Tracker.new)
+
+        Timeout.timeout(1) do
+          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)
+
+        controller = DispatchController.new(
+          Options.new({:ui => "UI::Null"}),
+          [receiver]
+        )
+
+        controller.dispatch(:method_call)
+        assert_raises(NoDispatchReceiversError) {controller.dispatch(:another_call)}
+      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 = 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
+
+      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 = Options.new({:ui => "UI::Null"})
+        controller = DispatchController.new(
+          options, []
+        )
+
+        assert_raises(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
+  end
+end

data/test/deep_test/distributed/filename_resolver_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+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)
+
+        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 = FilenameResolver.new("base_path")
+
+        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
+
+      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)
+
+        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 = 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)
+
+        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 = 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")
+
+        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

data/test/deep_test/distributed/landing_ship_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "generates a local working copy path based on host and source of request" do
+        Socket.stubs(:gethostname).returns("myhost")
+        Telegraph::Wire.stubs(:connect).returns :wire
+        landing_ship = LandingShip.new(:address => "host")
+        options = Options.new(:sync_options => {:source => "/my/local/dir"})
+        RSync.expects(:push).with("host", options.sync_options, "/tmp/myhost_my_local_dir")
+        landing_ship.push_code(options)
+      end
+
+      test "establish_beachhead launches beachhead process on remote machine" do
+        Socket.stubs(:gethostname).returns("myhost")
+        Telegraph::Wire.stubs(:connect).returns :wire
+        landing_ship = LandingShip.new(:address => "remote_host")
+        options = Options.new(:sync_options => {:source => "/my/local/dir"})
+
+        landing_ship.expects(:`).with(
+          "ssh -4 remote_host " + 
+          "'#{ShellEnvironment.like_login} && cd /tmp/myhost_my_local_dir && " + 
+          "OPTIONS=#{options.to_command_line} " + 
+          "ruby lib/deep_test/distributed/establish_beachhead.rb' 2>&1"
+        ).returns("blah blah\nBeachhead port: 9999\nblah")
+
+        landing_ship.establish_beachhead(options)
+      end
+
+      test "establish_beachhead launches beachhead process on remote machine with usernames specified in sync_options" do
+        Socket.stubs(:gethostname).returns("myhost")
+        Telegraph::Wire.stubs(:connect).returns :wire
+        landing_ship = LandingShip.new(:address => "remote_host")
+        options = Options.new(:sync_options => {:username => "me", :source => "/my/local/dir"})
+
+        landing_ship.expects(:`).with(
+          "ssh -4 remote_host -l me " + 
+          "'#{ShellEnvironment.like_login} && cd /tmp/myhost_my_local_dir && " + 
+          "OPTIONS=#{options.to_command_line} " + 
+          "ruby lib/deep_test/distributed/establish_beachhead.rb' 2>&1"
+        ).returns("blah blah\nBeachhead port: 9999\nblah")
+
+        landing_ship.establish_beachhead(options)
+      end
+    end
+  end
+end

data/test/deep_test/distributed/remote_deployment_test.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "load_files broadcasts before_sync" do
+        class FakeListener; end
+        deployment = RemoteDeployment.new(
+          options = Options.new(:listener => FakeListener,
+                                :sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+        FakeListener.any_instance.expects(:before_sync)
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+      end
+
+      test "load_files pushes code to remote machines" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:push_code).with(options)
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+      end
+
+      test "load_files loads files locally" do
+        beachhead = stub_everything
+        deployment = RemoteDeployment.new(
+          Options.new(:sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        deployment.expects(:load).with("filelist")
+        deployment.load_files ["filelist"]
+      end
+
+      test "deploy_agents starts agents on agent server" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:establish_beachhead).with(options)  
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        landing_ship.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception in deploy_agents causes failover to failover_deployment" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:establish_beachhead).with(options)  
+        landing_ship.expects(:load_files)
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        landing_ship.expects(:deploy_agents).raises("An Error")
+
+        failover_deployment.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception in push_code causes failover to failover_deployment" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = mock,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:push_code).raises("An Error")
+
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        failover_deployment.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception in load_files causes failover to failover_deployment" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = mock,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:push_code)
+        landing_ship.expects(:establish_beachhead)
+        landing_ship.expects(:load_files).raises("An Error")
+
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        failover_deployment.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception from deploy_agents of failover_deployment is raised" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:establish_beachhead).with(options)
+        landing_ship.expects(:load_files).raises("An Error")
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        failover_deployment.expects(:deploy_agents).raises("Failover Error").then.returns(nil)
+
+        begin 
+          deployment.deploy_agents
+          flunk
+        rescue RuntimeError => e
+          assert_equal "Failover Error", e.message
+        end
+      end
+    end
+  end
+end