jstorimer-deep-test 1.4.0 → 2.0.0

data/test/deep_test/distributed/remote_worker_client_test.rb

@@ -1,180 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

data/test/deep_test/distributed/test_server_test.rb

@@ -1,94 +0,0 @@
-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
-    )
-
-    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

data/test/deep_test/distributed/test_server_workers_test.rb

@@ -1,26 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-unit_tests do
-  test "number_of_workers is determined by mirror server options" do
-    workers = DeepTest::Distributed::TestServerWorkers.new(
-      DeepTest::Options.new({}),
-      {:number_of_workers => 4},
-      mock
-    )
-
-    assert_equal 4, workers.number_of_workers
-  end
-
-  test "server is retrieved using client connection information" do
-    workers = DeepTest::Distributed::TestServerWorkers.new(
-      options = DeepTest::Options.new({}),
-      {:number_of_workers => 4},
-      mock(:address => "address")
-    )
-    DeepTest::Server.expects(:remote_reference).
-      with("address", options.server_port).
-      returns(:server_reference)
-
-    assert_equal :server_reference, workers.server
-  end
-end

data/test/deep_test/distributed/throughput_runner_test.rb

@@ -1,68 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-unit_tests do
-  test "runner adds specified number of work units to blackboard" do
-    blackboard = DeepTest::SimpleTestBlackboard.new
-    runner = DeepTest::Distributed::ThroughputRunner.new(
-      DeepTest::Options.new({}),
-      5,
-      blackboard
-    )
-
-    worker = ThreadWorker.new(blackboard, 5)
-    Timeout.timeout(5) do
-      runner.process_work_units
-    end
-    worker.wait_until_done
-  end
-
-  test "runner yields all results from blackboard" do
-    blackboard = DeepTest::SimpleTestBlackboard.new
-    count = 0
-    runner = DeepTest::Distributed::ThroughputRunner.new(
-      DeepTest::Options.new({}),
-      2,
-      blackboard
-    ) do |result|
-      assert_equal :null_work_unit_result, result
-      count += 1
-    end
-
-    worker = ThreadWorker.new(blackboard, 2)
-    Timeout.timeout(5) do
-      runner.process_work_units
-    end
-    worker.wait_until_done
-
-    assert_equal 2, count
-  end
-
-  test "statistics are available after run" do
-    blackboard = DeepTest::SimpleTestBlackboard.new
-    runner = DeepTest::Distributed::ThroughputRunner.new(
-      DeepTest::Options.new({}),
-      2,
-      blackboard
-    )
-
-    worker = ThreadWorker.new(blackboard, 2)
-    count = 0
-    Timeout.timeout(5) do
-      runner.process_work_units
-    end
-    worker.wait_until_done
-
-    assert_kind_of DeepTest::Distributed::ThroughputStatistics,
-                   runner.statistics
-  end
-
-  test "runner returns true" do
-    runner = DeepTest::Distributed::ThroughputRunner.new(
-      DeepTest::Options.new({}),
-      0,
-      DeepTest::SimpleTestBlackboard.new 
-    )
-
-    assert_equal true, runner.process_work_units
-  end
-end