jstorimer-deep-test 0.2.0 → 1.0.0

data/test/deep_test/distributed/rsync_test.rb

@@ -1,47 +1,67 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-module DeepTest
-  module Distributed
-    unit_tests do
-      test "push executes rsync with using destination as remote location" do
-        RSync.expects(:system).
-           with("rsync -az --delete #{DeepTest::LIB_ROOT} source host:destination").returns(true)
-
-        RSync.push('host', {:source => "source"}, "destination")
-      end
-
-      test "raises error if push fails" do
-        RSync.expects(:system).returns(false)
-
-        assert_raises(RuntimeError) do
-          RSync.push(mock, {:source => "a", :local => true}, "destination")
-        end
-      end
-
-      test "include rsync_options in command" do
-        args = RSync::Args.new(mock, {:local => true, :rsync_options => "opt1 opt2"})
-        assert_equal "rsync -az --delete opt1 opt2 #{DeepTest::LIB_ROOT}", args.command("", "")
-      end
-
-      test "includes host in remote_location" do
-        args = RSync::Args.new('host', {})
-        assert_equal "host:dest", args.remote_location('dest')
-      end
-
-      test "separates host and dest with double colon if using daemon" do
-        args = RSync::Args.new('host', {:daemon => true})
-        assert_equal "host::dest", args.remote_location('dest')
-      end
-
-      test "includes username in dest_location if specified" do
-        args = RSync::Args.new('host', {:username => "user"})
-        assert_equal "user@host:dest", args.remote_location('dest')
-      end
-
-      test "does not include host in dest_location if local is specified" do
-        args = RSync::Args.new(mock, {:local => true})
-        assert_equal "dest", args.remote_location('dest')
-      end
+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
+    )
+
+    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

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

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

data/test/deep_test/distributed/throughput_worker_client_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "start_all starts workers on a new worker server" do
+    client = DeepTest::Distributed::ThroughputWorkerClient.new(
+      options = DeepTest::Options.new({}),
+      test_server = stub_everything
+    )
+
+    test_server.expects(:spawn_worker_server).with(options).
+      returns(worker_server = stub_everything)
+
+    worker_server.expects(:start_all)
+    client.start_all
+  end
+
+  test "stop_all stops workers on worker server that was spawned in start_all" do
+    worker_server = stub_everything
+    client = DeepTest::Distributed::ThroughputWorkerClient.new(
+      DeepTest::Options.new({}),
+      test_server = stub_everything(:spawn_worker_server => worker_server)
+    )
+
+    client.start_all
+    worker_server.expects(:stop_all)
+    client.stop_all
+  end
+end

data/test/deep_test/listener_list_test.rb

@@ -1,22 +1,20 @@
 require File.dirname(__FILE__) + "/../test_helper"
 
-module DeepTest
-  unit_tests do
-    test "forwards methods defined in NullListener to all listeners" do
-      listener_1, listener_2 = mock, mock
-      list = ListenerList.new([listener_1, listener_2])
-      listener_1.expects(:starting).with(:agent)
-      listener_2.expects(:starting).with(:agent)
-      listener_1.expects(:starting_work).with(:agent, :work)
-      listener_2.expects(:starting_work).with(:agent, :work)
-      list.starting(:agent)
-      list.starting_work(:agent, :work)
-    end
+unit_tests do
+  test "forwards methods defined in NullWorkerListener to all listeners" do
+    listener_1, listener_2 = mock, mock
+    list = DeepTest::ListenerList.new([listener_1, listener_2])
+    listener_1.expects(:starting).with(:worker)
+    listener_2.expects(:starting).with(:worker)
+    listener_1.expects(:starting_work).with(:worker, :work)
+    listener_2.expects(:starting_work).with(:worker, :work)
+    list.starting(:worker)
+    list.starting_work(:worker, :work)
+  end
 
-    test "doesn't forward methods not defined in NullListener" do
-      listener = mock
-      listener.expects(:to_s).never
-      ListenerList.new([listener]).to_s
-    end
+  test "doesn't forward methods not defined in NullWorkerListener" do
+    listener = mock
+    listener.expects(:to_s).never
+    DeepTest::ListenerList.new([listener]).to_s
   end
 end

data/test/deep_test/local_workers_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "number_of_workers is determined by options" do
+    workers = DeepTest::LocalWorkers.new(
+      DeepTest::Options.new(:number_of_workers => 4)
+    )
+
+    assert_equal 4, workers.number_of_workers
+  end
+
+  test "load_files simply loads each file provided" do
+    workers = DeepTest::LocalWorkers.new(
+      DeepTest::Options.new(:number_of_workers => 4)
+    )
+
+    workers.expects(:load).with(:file_1)
+    workers.expects(:load).with(:file_2)
+
+    workers.load_files([:file_1, :file_2])
+  end
+end

data/test/deep_test/logger_test.rb

@@ -1,38 +1,11 @@
 require File.dirname(__FILE__) + "/../test_helper"
 
-module DeepTest
-  unit_tests do
-    test "info log level by default" do
-      assert_equal Logger::INFO, DeepTest.logger.level
-    end
-    
-    test "formatter uses msg only" do
-      time = Time.parse("2009-09-22 12:01:33")
-      assert_equal "[DeepTest@#{Socket.gethostname}] 2009-09-22 12:01:33 my_msg\n", DeepTest.logger.formatter.call(nil, time, nil, "my_msg")
-    end
-
-    Logger::Severity.constants.each do |severity|
-      test "#{severity.downcase} can not be called with any arguments" do
-        logger = Logger.new stub_everything
-        assert_raises(ArgumentError) { logger.send severity.downcase, "a"  }
-      end
-
-      THE_DATE = '\d{4}-\d\d-\d\d \d\d:\d\d:\d\d' unless defined?(THE_DATE)
-
-      test "#{severity.downcase} can be called with a block" do
-        logger = Logger.new(out = StringIO.new)
-        logger.level = Logger.const_get(severity)
-        logger.send(severity.downcase) { "a" }
-        assert_match /\[DeepTest@#{Socket.gethostname}\] #{THE_DATE} a\n/, out.string
-      end
-
-      test "#{severity.downcase} rescues errors from block and logs them" do
-        logger = Logger.new(out = StringIO.new)
-        logger.level = Logger.const_get(severity)
-        logger.send(severity.downcase) { raise Exception, "e" }
-        assert_match /\[DeepTest@#{Socket.gethostname}\] #{THE_DATE} Exception: e occurred logging on #{__FILE__}:#{__LINE__ - 1}:in `send'\n/,
-                    out.string
-      end
-    end
+unit_tests do
+  test "info log level by default" do
+    assert_equal Logger::INFO, DeepTest.logger.level
+  end
+  
+  test "formatter uses msg only" do
+    assert_equal "[DeepTest] my_msg\n", DeepTest.logger.formatter.call(nil, nil, nil, "my_msg")
   end
 end

data/test/deep_test/marshallable_exception_wrapper_test.rb

@@ -1,46 +1,44 @@
 require File.dirname(__FILE__) + "/../test_helper"
 
-module DeepTest
-  unit_tests do
-    test "loading a marshallable exception evals the classname and returns an instance of the original exception" do
-      original = RuntimeError.new "message"
-      original.set_backtrace ['1', '2']
+unit_tests do
+  test "loading a marshallable exception evals the classname and returns an instance of the original exception" do
+    original = RuntimeError.new "message"
+    original.set_backtrace ['1', '2']
 
-      marshalled = MarshallableExceptionWrapper.new(original)
-      MarshallableExceptionWrapper.any_instance.expects(:eval).
-        with("::RuntimeError").returns(RuntimeError)
+    marshalled = DeepTest::MarshallableExceptionWrapper.new(original)
+    DeepTest::MarshallableExceptionWrapper.any_instance.expects(:eval).
+      with("::RuntimeError").returns(RuntimeError)
 
-      loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
 
-      assert_equal original.class,     loaded.class
-      assert_equal original.message,   loaded.message
-      assert_equal original.backtrace, loaded.backtrace
-    end
+    assert_equal original.class,     loaded.class
+    assert_equal original.message,   loaded.message
+    assert_equal original.backtrace, loaded.backtrace
+  end
 
-    test "loading a marshallable exception when class is not available returns an instance of unloadable exception" do
-      original = RuntimeError.new "message"
-      original.set_backtrace ['1', '2']
+  test "loading a marshallable exception when class is not available returns an instance of unloadable exception" do
+    original = RuntimeError.new "message"
+    original.set_backtrace ['1', '2']
 
-      marshalled = MarshallableExceptionWrapper.new(original)
-      MarshallableExceptionWrapper.any_instance.expects(:eval).
-        raises("Eval Error")
+    marshalled = DeepTest::MarshallableExceptionWrapper.new(original)
+    DeepTest::MarshallableExceptionWrapper.any_instance.expects(:eval).
+      raises("Eval Error")
 
-      loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
 
-      assert_equal UnloadableException, loaded.class
-      assert_equal "RuntimeError: " + original.message,   loaded.message
-      assert_equal original.backtrace, loaded.backtrace
-    end
+    assert_equal DeepTest::UnloadableException, loaded.class
+    assert_equal "RuntimeError: " + original.message,   loaded.message
+    assert_equal original.backtrace, loaded.backtrace
+  end
 
-    test "loading a marshallable exception when class init throws an error returns an unloadable exception" do
-      original = RuntimeError.new "message"
+  test "loading a marshallable exception when class init throws an error returns an unloadable exception" do
+    original = RuntimeError.new "message"
 
-      marshalled = MarshallableExceptionWrapper.new(original)
-      RuntimeError.expects(:new).raises(StandardError.new)
+    marshalled = DeepTest::MarshallableExceptionWrapper.new(original)
+    RuntimeError.expects(:new).raises(StandardError.new)
 
-      loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
 
-      assert_equal UnloadableException, loaded.class
-    end
+    assert_equal DeepTest::UnloadableException, loaded.class
   end
 end