jason-o-matic-deep_test 1.2.2.1

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,107 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "start_all delegates to worker implementation" do
+    options = DeepTest::Options.new(:libs => [], :requires => [])
+    server = DeepTest::Distributed::RemoteWorkerServer.new("", implementation = mock, options)
+    implementation.expects(:start_all)
+    server.start_all
+  end
+
+  test "stop_all delegates to worker implementation" do
+    options = DeepTest::Options.new(:libs => [], :requires => [])
+    server = DeepTest::Distributed::RemoteWorkerServer.new("", implementation = mock, options)
+    implementation.expects(:stop_all)
+    server.stop_all
+  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
+    options = DeepTest::Options.new(:libs => [], :requires => [])
+
+    server = DeepTest::Distributed::RemoteWorkerServer.new("", implementation, options)
+    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
+    options = DeepTest::Options.new(:libs => [], :requires => [])
+    DeepTest::Distributed::FilenameResolver.expects(:new).times(2).with("/mirror/dir").
+      returns(resolver = mock)
+
+    server = DeepTest::Distributed::RemoteWorkerServer.new("/mirror/dir", stub_everything, options)
+
+    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
+    options = DeepTest::Options.new(:libs => [], :requires => [])
+    log_level = DeepTest.logger.level
+    begin
+      DeepTest.logger.level = Logger::ERROR
+      DeepTest::Distributed::RemoteWorkerServer.start(
+        "localhost",                                              
+        "base_path",
+        stub_everything,
+        options,
+        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
+    options = DeepTest::Options.new(:libs => [], :requires => [])
+    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,
+          options,
+          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

data/test/deep_test/distributed/rsync_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "executes rsync with source and destination" do
+    options = DeepTest::Options.new(:sync_options => {:source => "source", :local => true})
+
+    DeepTest::Distributed::RSync.expects(:system).
+       with("rsync -az --delete source/ destination").returns(true)
+
+    DeepTest::Distributed::RSync.sync(mock, options, "destination")
+  end
+
+  test "raises error if sync fails" do
+    DeepTest::Distributed::RSync.expects(:system).returns(false)
+
+    assert_raises(RuntimeError) do
+      DeepTest::Distributed::RSync.sync(
+        mock,
+        DeepTest::Options.new(:sync_options => {:source => "a", :local => true}),
+        "destination"
+      )
+    end
+  end
+
+  test "include rsync_options in command" do
+    options = DeepTest::Options.new(:sync_options => {:source => "source", 
+                                                      :local => true,
+                                                      :rsync_options => "opt1 opt2"})
+
+    args = DeepTest::Distributed::RSync::Args.new(mock, options)
+    assert_equal "rsync -az --delete opt1 opt2 source/", args.command("")
+  end
+
+  test "includes host in source_location" do
+    options = DeepTest::Options.new(:sync_options => {:source => "source"})
+    args = DeepTest::Distributed::RSync::Args.new(mock(:address => 'host'), 
+                                                  options)
+
+    assert_equal "host:source", args.source_location
+  end
+
+  test "separates host and source with double colon if using daemon" do
+    options = DeepTest::Options.new(
+      :sync_options => {:source => "source", :daemon => true}
+    )
+    args = DeepTest::Distributed::RSync::Args.new(mock(:address => 'host'), 
+                                                  options)
+
+    assert_equal "host::source", args.source_location
+  end
+
+  test "includes username in source_location if specified" do
+    options = DeepTest::Options.new(:sync_options => {:source => "source", 
+                                                      :username => "user"})
+    args = DeepTest::Distributed::RSync::Args.new(mock(:address => 'host'),
+                                                  options)
+
+    assert_equal "user@host:source", args.source_location
+  end
+
+  test "does not include host in source_location if local is specified" do
+    options = DeepTest::Options.new(:sync_options => {:source => "source", :local => true})
+    args = DeepTest::Distributed::RSync::Args.new(mock, options)
+
+    assert_equal "source", args.source_location
+  end
+end

data/test/deep_test/distributed/test_server_test.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "generates a local working copy path based on host and source of request" do
+    DeepTest::Distributed::DRbClientConnectionInfo.expects(:new).
+      returns(:connection_info)
+
+    Socket.stubs(:gethostname).returns("myhost", "serverhost")
+    server = DeepTest::Distributed::TestServer.new(:work_dir => "/tmp")
+    options = DeepTest::Options.new(:sync_options => {:source => "/my/local/dir"})
+    DeepTest::Distributed::RSync.expects(:sync).with(:connection_info,
+                                                     options,
+                                                     "/tmp/myhost_my_local_dir")
+    server.sync(options)
+  end
+
+  test "work_dir can be set from command line" do
+    config = DeepTest::Distributed::TestServer.parse_args(
+      ['--work_dir','path']
+    )
+    assert_equal 'path', config[:work_dir]
+  end
+
+  test "uri can be set from command line" do
+    config = DeepTest::Distributed::TestServer.parse_args(['--uri','uri'])
+    assert_equal 'uri', config[:uri]
+  end
+
+  test "number_of_workers can be set from command line" do
+    config = DeepTest::Distributed::TestServer.parse_args(
+      ['--number_of_workers','4']
+    )
+    assert_equal 4, config[:number_of_workers]
+  end
+
+  test "default number_of_workers is 2" do
+    assert_equal(
+      2, 
+      DeepTest::Distributed::TestServer::DEFAULT_CONFIG[:number_of_workers]
+    )
+  end
+
+  test "uses default options for those not specified" do
+    config = DeepTest::Distributed::TestServer.parse_args([])
+    assert_equal DeepTest::Distributed::TestServer::DEFAULT_CONFIG, config
+  end
+
+  test "spawn_worker_server starts RemoteWorkerServer with TestServerWorkers" do
+    config = {:number_of_workers => 4, :uri => "druby://localhost:4022"}
+    server = DeepTest::Distributed::TestServer.new(config)
+    options = DeepTest::Options.new(:sync_options => {:source => ""})
+    DeepTest::Distributed::DRbClientConnectionInfo.expects(:new).
+      returns(:connection_info)
+
+    DeepTest::Distributed::TestServerWorkers.expects(:new).with(
+      options, config, :connection_info
+    ).returns(:workers)
+  
+    DeepTest::Distributed::RemoteWorkerServer.expects(:start).with(
+      "localhost", anything, :workers, options
+    )
+
+    server.spawn_worker_server(options)
+  end
+
+  test "connect creates dispatch controller for all servers" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    DRbObject.expects(:new_with_uri).returns(server = mock)
+    server.expects(:servers).returns([s1 = mock, s2 = mock])
+    s1.expects(:sync)
+    s2.expects(:sync)
+    DeepTest::Distributed::TestServer.connect(options).sync(options)
+  end
+
+  test "status.binding_uri is the uri that DRb is bound to" do
+    server = DeepTest::Distributed::TestServer.new(:number_of_workers => 4)
+    DRb.expects(:uri).returns("druby://test")
+    assert_equal "druby://test", server.status.binding_uri
+  end
+
+  test "status.number_of_workers in the configured number of workers" do
+    server = DeepTest::Distributed::TestServer.new(:number_of_workers => 4)
+    DRb.expects(:uri)
+    assert_equal 4, server.status.number_of_workers
+  end
+
+  test "status.remote_worker_server_count is number of servers currently running" do
+    server = DeepTest::Distributed::TestServer.new(:number_of_workers => 4)
+    DRb.expects(:uri)
+    DeepTest::Distributed::RemoteWorkerServer.expects(:running_server_count).
+      returns(3)
+    assert_equal 3, server.status.remote_worker_server_count
+  end
+end