jstorimer-deep-test 0.2.0 → 1.0.0

data/test/deep_test/distributed/filename_resolver_test.rb

@@ -1,56 +1,52 @@
 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")
+unit_tests do
+  test "should strip off directories until file exists in base path" do
+    resolver = DeepTest::Distributed::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 = FilenameResolver.new("base_path")
+  test "should resolve relative names starting at first element" do
+    resolver = DeepTest::Distributed::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 = FilenameResolver.new("base_path")
+  test "should resolve relative names the same each time" do
+    resolver = DeepTest::Distributed::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 = FilenameResolver.new("base_path")
+  test "should raise exception if filename can't be resolved" do
+    resolver = DeepTest::Distributed::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 = FilenameResolver.new("base_path")
+  test "should remember how many directories to strip off after first resolution" do
+    resolver = DeepTest::Distributed::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")
-      end
-    end
+    assert_equal "base_path/x/y/z.rb", resolver.resolve("/a/x/y/z.rb")
   end
 end

data/test/deep_test/distributed/master_test_server_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "show_status renders status of all servers as html" do
+    status = DeepTest::Distributed::TestServerStatus.new(
+      "binding_uri", 
+      5,
+      3
+    )
+
+    test_server = mock(:__drburi => "drburi_1", :status => status) 
+    server = DeepTest::Distributed::MasterTestServer.new([test_server])
+    res = WEBrick::HTTPResponse.new(WEBrick::Config::HTTP)
+    server.show_status(:req, res)
+
+    assert_match "<td>binding_uri</td>", res.body
+    assert_match "<td>5</td>", res.body
+    assert_match "<td>3</td>", res.body
+  end
+
+  test "show_status display error message if exception occurs" do
+    test_server = mock(:__drburi => "drburi_1")
+    test_server.expects(:status).raises("An Error")
+
+    server = DeepTest::Distributed::MasterTestServer.new([test_server])
+
+    res = WEBrick::HTTPResponse.new(WEBrick::Config::HTTP)
+    server.show_status(:req, res)
+
+    assert_match /<td.*?>An Error<\/td>/, res.body
+  end
+end

data/test/deep_test/distributed/multi_test_server_proxy_test.rb

@@ -0,0 +1,96 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "sync is invoked on all servers" do
+    server_1, server_2 = mock, mock
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+
+    master = DeepTest::Distributed::MultiTestServerProxy.new(options, [server_1, server_2])
+
+    server_1.expects(:sync).with(options)
+    server_2.expects(:sync).with(options)
+
+    master.sync(options)
+  end
+
+  test "spawn_worker_server is invoked on all server" do
+    server_1, server_2 = mock, mock
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+
+    master = DeepTest::Distributed::MultiTestServerProxy.new(options, [server_1, server_2])
+
+    server_1.expects(:spawn_worker_server).with(options)
+    server_2.expects(:spawn_worker_server).with(options)
+
+    master.spawn_worker_server(options)
+  end
+
+  test "spawn_worker_server returns WorkerServerProxy with each worker" do
+    server_1 = mock(:spawn_worker_server => :worker_server_1)
+    server_2 = mock(:spawn_worker_server => :worker_server_2)
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+
+    master = DeepTest::Distributed::MultiTestServerProxy.new(options, [server_1, server_2])
+
+    DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.
+      expects(:new).with(options, [:worker_server_1, :worker_server_2])
+
+    master.spawn_worker_server(options)
+  end
+
+  test "WorkerServerProxy dispatches start_all" do
+    server_1, server_2 = mock, mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1, server_2]
+    )
+
+    server_1.expects(:start_all)
+    server_2.expects(:start_all)
+
+    master.start_all
+  end
+
+  test "WorkerServerProxy dispatches stop_all" do
+    server_1, server_2 = mock, mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1, server_2]
+    )
+
+    server_1.expects(:stop_all)
+    server_2.expects(:stop_all)
+
+    master.stop_all
+  end
+
+  test "WorkerServerProxy stop_all ignores connection errors" do
+    server_1 = mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1]
+    )
+
+    server_1.expects(:__drburi).never
+    server_1.expects(:stop_all).raises(DRb::DRbConnError)
+
+    master.stop_all
+  end
+
+  test "WorkerServerProxy dispatches load_files" do
+    server_1, server_2 = mock, mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1, server_2]
+    )
+
+    server_1.expects(:load_files).with(:filelist)
+    server_2.expects(:load_files).with(:filelist)
+
+    master.load_files :filelist
+  end
+end

data/test/deep_test/distributed/remote_worker_client_test.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "load_files broadcasts before_sync" do
+    class FakeListener; end
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      options = DeepTest::Options.new(:worker_listener => FakeListener,
+                                      :sync_options => {:source => "/tmp"}),
+      test_server = stub_everything(:spawn_worker_server => stub_everything),
+      failover_workers = mock
+    )
+    FakeListener.any_instance.expects(:before_sync)
+    client.expects(:load)
+    client.load_files ["filelist"]
+
+  end
+
+  test "load_files syncs the mirror" do
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      options = DeepTest::Options.new(:sync_options => {:source => "/tmp"}),
+      test_server = stub_everything(:spawn_worker_server => stub_everything),
+      failover_workers = mock
+    )
+
+    test_server.expects(:sync).with(options)
+    client.expects(:load)
+    client.load_files ["filelist"]
+  end
+
+  test "load_files loads files on worker server" do
+    worker_server = stub_everything
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      DeepTest::Options.new(:sync_options => {:source => "/tmp"}),
+      test_server = stub_everything(:spawn_worker_server => worker_server),
+      failover_workers = mock
+    )
+
+    worker_server.expects(:load_files).with(["filelist"])
+    client.expects(:load)
+    client.load_files ["filelist"]
+  end
+
+  test "load_files loads files locally" do
+    worker_server = stub_everything
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      DeepTest::Options.new(:sync_options => {:source => "/tmp"}),
+      test_server = stub_everything(:spawn_worker_server => worker_server),
+      failover_workers = mock
+    )
+
+    client.expects(:load).with("filelist")
+    client.load_files ["filelist"]
+  end
+
+  test "start_all starts workers on worker server" do
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      options = DeepTest::Options.new(:sync_options => {:source => "/tmp"}),
+      test_server = stub_everything,
+      failover_workers = mock
+    )
+
+    test_server.expects(:spawn_worker_server).with(options).
+      returns(worker_server = stub_everything)
+
+    client.expects(:load)
+    client.load_files ["filelist"]
+
+    worker_server.expects(:start_all)
+    client.start_all
+  end
+
+  test "stop_all stops workers on worker server that was spawned in load_files" do
+    worker_server = stub_everything
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      DeepTest::Options.new(:sync_options => {:source => "/tmp"}),
+      test_server = stub_everything(:spawn_worker_server => worker_server),
+      failover_workers = mock
+    )
+
+    client.expects(:load)
+    client.load_files ["filelist"]
+
+    worker_server.expects(:stop_all)
+    client.stop_all
+  end
+
+  test "exception in start_all causes failover to failover_workers" do
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      options = DeepTest::Options.new(:sync_options => {:source => "/tmp"}, :ui => DeepTest::UI::Null),
+      test_server = stub_everything,
+      failover_workers = mock
+    )
+
+    test_server.expects(:spawn_worker_server).with(options).
+      returns(worker_server = mock)
+
+    worker_server.expects(:load_files)
+    client.expects(:load)
+    client.load_files ["filelist"]
+
+    worker_server.expects(:start_all).raises("An Error")
+
+    failover_workers.expects(:start_all)
+    client.start_all
+
+    failover_workers.expects(:stop_all)
+    client.stop_all
+  end
+
+  test "exception in sync causes failover to failover_workers" do
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      options = DeepTest::Options.new(:sync_options => {:source => "/tmp"}, :ui => DeepTest::UI::Null),
+      test_server = mock,
+      failover_workers = mock
+    )
+
+    test_server.expects(:sync).raises("An Error")
+
+    client.expects(:load)
+    client.load_files ["filelist"]
+
+    failover_workers.expects(:start_all)
+    client.start_all
+
+    failover_workers.expects(:stop_all)
+    client.stop_all
+  end
+
+  test "exception in load_files causes failover to failover_workers" do
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      options = DeepTest::Options.new(:sync_options => {:source => "/tmp"}, :ui => DeepTest::UI::Null),
+      test_server = stub_everything,
+      failover_workers = mock
+    )
+
+    test_server.expects(:spawn_worker_server).with(options).
+      returns(worker_server = Object.new)
+
+    worker_server.instance_eval do
+      def calls() @calls ||= []; end
+      def method_missing(sym, *args) calls << sym; end
+      def load_files(filelist) raise "An Error"; end
+    end
+
+    client.expects(:load)
+    client.load_files ["filelist"]
+
+    failover_workers.expects(:start_all)
+    client.start_all
+
+    failover_workers.expects(:stop_all)
+    client.stop_all
+
+    assert_equal [], worker_server.calls
+  end
+
+  test "exception from start_all of failover_workers is raised" do
+    client = DeepTest::Distributed::RemoteWorkerClient.new(
+      options = DeepTest::Options.new(:sync_options => {:source => "/tmp"}, :ui => DeepTest::UI::Null),
+      test_server = stub_everything,
+      failover_workers = mock
+    )
+
+    test_server.expects(:spawn_worker_server).with(options).
+      returns(worker_server = mock)
+
+    worker_server.expects(:load_files).raises("An Error")
+    client.expects(:load)
+    client.load_files ["filelist"]
+
+    failover_workers.expects(:start_all).raises("Failover Error").then.returns(nil)
+
+    begin 
+      client.start_all
+      flunk
+    rescue RuntimeError => e
+      assert_equal "Failover Error", e.message
+    end
+  end
+end

data/test/deep_test/distributed/remote_worker_server_test.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "start_all delegates to worker implementation" do
+    server = DeepTest::Distributed::RemoteWorkerServer.new("", implementation = mock)
+    implementation.expects(:start_all)
+    server.start_all
+  end
+
+  test "stop_all delegates to worker implementation" do
+    server = DeepTest::Distributed::RemoteWorkerServer.new("", implementation = mock)
+    implementation.expects(:stop_all)
+    server.stop_all.join
+  end
+
+  test "stop_all returns without waiting for stops" do
+    implementation = Object.new.instance_eval do
+      def done?
+        @done == true
+      end
+
+      def stop_all
+        sleep 0.01
+        @done = true
+      end
+      self
+    end
+
+    server = DeepTest::Distributed::RemoteWorkerServer.new("", implementation)
+    server.stop_all
+    assert_equal false, implementation.done?
+
+    until implementation.done?
+      sleep 0.01
+    end
+  end
+  
+  test "load_files loads each file in list, resolving each filename with resolver" do
+    DeepTest::Distributed::FilenameResolver.expects(:new).with("/mirror/dir").
+      returns(resolver = mock)
+
+    server = DeepTest::Distributed::RemoteWorkerServer.new("/mirror/dir", stub_everything)
+
+    resolver.expects(:resolve).with("/source/path/my/file.rb").
+      returns("/mirror/dir/my/file.rb")
+    server.expects(:load).with("/mirror/dir/my/file.rb")
+    Dir.expects(:chdir).with("/mirror/dir")
+
+    server.load_files(["/source/path/my/file.rb"])
+  end
+
+  test "service is removed after grace period if workers haven't been started" do
+    log_level = DeepTest.logger.level
+    begin
+      DeepTest.logger.level = Logger::ERROR
+      DeepTest::Distributed::RemoteWorkerServer.start(
+        "localhost",                                              
+        "base_path",
+        stub_everything,
+        0.25
+      )
+      # Have to sleep long enough to warlock to reap dead process
+      sleep 1.0
+      assert_equal 0, DeepTest::Distributed::RemoteWorkerServer.running_server_count
+    ensure
+      begin
+        DeepTest::Distributed::RemoteWorkerServer.stop_all
+      ensure
+        DeepTest.logger.level = log_level
+      end
+    end
+  end
+
+  test "service is not removed after grace period if workers have been started" do
+    log_level = DeepTest.logger.level
+    begin
+      DeepTest.logger.level = Logger::ERROR
+      server = nil
+      capture_stdout do
+        server = DeepTest::Distributed::RemoteWorkerServer.start(
+          Socket.gethostname,
+          "", 
+          stub_everything,
+          0.25
+        )
+      end
+      server.start_all
+      # Have to sleep long enough to warlock to reap dead process
+      sleep 1.0
+      assert_equal 1, DeepTest::Distributed::RemoteWorkerServer.running_server_count
+    ensure
+      begin
+        DeepTest::Distributed::RemoteWorkerServer.stop_all
+      ensure
+        DeepTest.logger.level = log_level
+      end
+    end
+  end
+end