jstorimer-deep-test 1.4.0 → 2.0.0

data/negative_acceptance_tests/tests.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'test/unit'
+require 'dust'
+require 'timeout'
+
+unit_tests do
+  [:test, :spec].each do |framework|
+    test "#{framework}: DeepTest a failing test results in failure" do
+      result, output = run_rake framework, :failing
+      assert_equal false, result.success?, output
+    end
+
+    test "#{framework}: Distributed DeepTest with failover to local" do
+      result, output = run_rake framework, :failover_to_local
+      assert_equal true, result.success?, output
+      assert_match /RSync Failed!!/, output
+      assert_match /Failing over to local run/, output
+    end
+
+    test "#{framework}: Distributed DeepTest with a host down" do
+      result, output = run_rake framework, :just_one_with_host_down
+      assert_equal true, result.success?, output
+      assert_match /RSync Failed!!/, output
+      assert_no_match /Failing over to local run/, output
+    end
+
+    test "#{framework}: DeepTest with agents that die" do
+      result, output = run_rake framework, :with_agents_dying
+      assert_equal false, result.success?, output
+      assert_match /DeepTest Agents Are Not Running/, output
+      assert_match /DeepTest::IncompleteTestRunError.*100 tests were not run because the DeepTest Agents died/m, output
+    end
+    
+    test "#{framework}: DeepTest processes go away after the test run ends" do
+      Timeout.timeout(15) { run_rake framework, :passing }
+    end
+
+    test "#{framework}: DeepTest with work taken and not done" do
+      result, output = run_rake framework, :with_work_taken_and_not_done 
+      assert_equal true, result.success?, output
+    end
+
+    test "#{framework}: DeepTest with metrics" do
+      FileUtils.rm_f "negative_acceptance_tests/metrics.data"
+      result, output = run_rake framework, :with_metrics
+      assert_equal true, result.success?, output
+      metrics = File.read("negative_acceptance_tests/metrics.data")
+      assert_match /Metrics Data/, metrics
+      assert_match /Agents Performing Work:/, metrics
+      assert_match /Agents Retrieving Work:/, metrics
+    end
+  end
+
+  def run_rake(framework, task)
+    command = "rake --rakefile #{File.dirname(__FILE__)}/tasks.rake deep_#{framework}_#{task} 2>&1"
+    output = `#{command}`.map {|l| "[rake deep_#{framework}_#{task}] #{l}" }.join
+    return $?, output
+  end
+
+end

data/sample_rails_project/deep_test.rb

@@ -12,6 +12,10 @@ unit_tests do
     assert_successful "rake deep_test"
   end
 
+  test "distributed_test" do
+    assert_successful "rake distributed_test" 
+  end
+
   test "spec" do
     assert_successful "rake spec"
   end

data/sample_rails_project/lib/{foreign_host_worker_simulation_listener.rb → foreign_host_agent_simulation_listener.rb}

@@ -1,11 +1,13 @@
-class ForeignHostWorkerSimulationListener < DeepTest::NullWorkerListener
-  def starting(worker)
+require File.dirname(__FILE__) + '/../vendor/gems/deep_test/lib/deep_test'
+
+class ForeignHostAgentSimulationListener < DeepTest::NullListener
+  def starting(agent)
     # On a foreign host, there won't necessarily be a database for tests
     # to run against.  We simulate that by dropping them here.
     #
-    # It's important that this happens as the first thing when the workers
+    # It's important that this happens as the first thing when the agents
     # are started, since this is the first listener event that would be
-    # invoked on a foreign host.  before_starting_workers would be invoked
+    # invoked on a foreign host.  before_starting_agents would be invoked
     # on the local host, which should have databases available as usual.
     #
     system "mysqladmin -u root -f drop sample_rails_project_development > /dev/null"

data/sample_rails_project/lib/tasks/deep_test.rake

@@ -1,18 +1,27 @@
 require 'rubygems'
 gem 'rspec', '=1.1.8'
 require 'spec/rake/spectask'
-$LOAD_PATH << File.dirname(__FILE__) + "/../../../lib"
+$LOAD_PATH << File.dirname(__FILE__) + "/../../vendor/gems/deep_test/lib"
 require 'deep_test/rake_tasks'
 
 DeepTest::TestTask.new(:deep_test) do |t|
-  t.number_of_workers = 1
+  t.number_of_agents = 1
   t.pattern = "test/unit/**/*_test.rb"
-  t.worker_listener = "ForeignHostWorkerSimulationListener,DeepTest::Database::MysqlSetupListener"
+  t.listener = "ForeignHostAgentSimulationListener,DeepTest::Database::MysqlSetupListener"
 end
 Rake::Task[:deep_test].enhance ["db:test:prepare"]
 
 Spec::Rake::SpecTask.new(:deep_spec) do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
-  t.deep_test :number_of_workers => 2
+  t.deep_test :number_of_agents => 2
 end
 Rake::Task[:deep_spec].enhance ["db:test:prepare"]
+
+DeepTest::TestTask.new(:distributed_test => %w[db:test:prepare]) do |t|
+  t.number_of_agents = 1
+  t.distributed_hosts = %w[localhost]
+  t.requires = File.dirname(__FILE__) + "/../foreign_host_agent_simulation_listener"
+  t.listener = "ForeignHostAgentSimulationListener,DeepTest::Database::MysqlSetupListener"
+  t.sync_options = {:source => File.expand_path(File.dirname(__FILE__) + "/../.."), 
+                    :rsync_options => "--exclude=.svn --copy-dirlinks"}
+end

data/spec/deep_test/options_spec.rb

@@ -2,59 +2,55 @@ require File.dirname(__FILE__) + "/../spec_helper"
 
 module DeepTest
   describe Options do
-    it "should support number_of_workers" do
-      Options.new(:number_of_workers => 3).number_of_workers.should == 3
+    it "should support number_of_agents" do
+      Options.new(:number_of_agents => 3).number_of_agents.should == 3
+    end
+
+    it "should default to number_of_agents based on cpu info at time of call" do
+      options = Options.new({})
+      CpuInfo.should_receive(:new).and_return stub("cpu_info", :count => 4)
+      options.number_of_agents.should == 4
     end
 
     it "should have reasonable defaults" do
       options = Options.new({})
-      options.number_of_workers.should == 2
-      options.timeout_in_seconds.should == 30
-      options.server_port.should == 6969
       options.pattern.should == nil
       options.metrics_file.should == nil
     end
 
-    it "should support timeout_in_seconds" do
-      Options.new(:timeout_in_seconds => 2).timeout_in_seconds.should == 2
-    end
-
     it "should support pattern" do
       Options.new(:pattern => '*').pattern.should == '*'
     end
 
-    it "should support distributed_server" do
-      Options.new(:distributed_server => "uri").distributed_server.should == "uri"
-    end
-
-    it "should support server_port" do
-      Options.new(:server_port => 10).server_port.should == 10
+    it "should support distributed_hosts" do
+      Options.new(:distributed_hosts => %w[host1 host2]).
+        distributed_hosts.should == %w[host1 host2]
     end
 
     it "should support sync_options" do
       Options.new(:sync_options => {:options => 1}).sync_options.should == {:options => 1}
     end
 
-    it "should support worker_listener" do
-      Options.new(:worker_listener => "AListener").
-        worker_listener.should == "AListener"
+    it "should support listener" do
+      Options.new(:listener => "AListener").
+        listener.should == "AListener"
     end
 
-    it "should use DeepTest::NullWorkerListener as the default listener" do
-      Options.new({}).worker_listener.should == "DeepTest::NullWorkerListener"
+    it "should use DeepTest::NullListener as the default listener" do
+      Options.new({}).listener.should == "DeepTest::NullListener"
     end
     
-    it "should allow worker_listener to be set with class" do
+    it "should allow listener to be set with class" do
       class FakeListener; end
-      Options.new(:worker_listener => FakeListener).
-        worker_listener.should == "DeepTest::FakeListener"
+      Options.new(:listener => FakeListener).
+        listener.should == "DeepTest::FakeListener"
     end
 
-    it "should allow multiple workers to be specified" do
+    it "should allow multiple listeners to be specified" do
       class FakeListener1; end
       class FakeListener2; end
       options = Options.new(
-        :worker_listener => "DeepTest::FakeListener1,DeepTest::FakeListener2"
+        :listener => "DeepTest::FakeListener1,DeepTest::FakeListener2"
       )
       listener = options.new_listener_list
       listener.should be_instance_of(DeepTest::ListenerList)
@@ -63,7 +59,7 @@ module DeepTest
       listener.listeners.last.should be_instance_of(FakeListener2)
     end
 
-    it "should create a list of worker listeners upon request" do
+    it "should create a list of agent listeners upon request" do
       Options.new({}).new_listener_list.should be_instance_of(DeepTest::ListenerList)
     end
 
@@ -92,7 +88,7 @@ module DeepTest
     end
 
     it "should support strings as well as symbols" do
-      Options.new("number_of_workers" => 2).number_of_workers.should == 2
+      Options.new("server_port" => 2).server_port.should == 2
     end
 
     it "should raise error when invalid option is specifed" do
@@ -102,42 +98,50 @@ module DeepTest
     end
 
     it "should convert to command line option string" do
-      options = Options.new(:number_of_workers => 1, :timeout_in_seconds => 3)
-      options.to_command_line.should == 
-        "--number_of_workers 1 --timeout_in_seconds 3"
+      options = Options.new(:number_of_agents => 1)
+      options.to_command_line.should == Base64.encode64(Marshal.dump(options)).gsub("\n","")
     end
 
     it "should parse from command line option string" do
-      options = Options.from_command_line( 
-        "--number_of_workers 2 --timeout_in_seconds 3 --pattern *")
-      options.number_of_workers.should == 2
-      options.timeout_in_seconds.should == 3
-      options.pattern.should == '*'
+      options = Options.new(:number_of_agents => 2, :pattern => '*')
+      parsed_options = Options.from_command_line(options.to_command_line)
+      parsed_options.number_of_agents.should == 2
+      parsed_options.pattern.should == '*'
     end
 
     it "should use default option value when no command line option is present" do
-      options = Options.from_command_line("")
-      options.number_of_workers.should == 2
+      ["", nil].each do |blank_value|
+        options = Options.from_command_line(blank_value)
+        options.ui == "DeepTest::UI::Console"
+      end
     end
 
-    it "should create local workers by default" do
+    it "should create local deployment by default" do
       options = Options.new({})
-      options.new_workers.should be_instance_of(LocalWorkers) 
+      options.new_deployment.should be_instance_of(LocalDeployment) 
     end
 
-    it "should create remote worker client when distributed server is specified" do
-      options = Options.new(:distributed_server => "uri", :sync_options => {:source => "root"})
-      Distributed::TestServer.should_receive(:connect).with(options).and_return(:server_instance)
-      Distributed::RemoteWorkerClient.should_receive(:new).with(options, :server_instance, be_instance_of(LocalWorkers))
-      options.new_workers
+    it "should create remote deployment when distributed hosts are specified" do
+      options = Options.new(:distributed_hosts => %w[hosts], :sync_options => {:source => "root"})
+      Distributed::RemoteDeployment.should_receive(:new).with(options, 
+                                                              be_instance_of(Distributed::LandingFleet), 
+                                                              be_instance_of(LocalDeployment))
+      options.new_deployment
     end
 
-    it "should create local workers when connect fails" do
-      options = Options.new(:distributed_server => "uri", :sync_options => {:source => "root"}, :ui => "DeepTest::UI::Null")
-      Distributed::TestServer.should_receive(:connect).and_raise("An error")
-      options.new_workers.should be_instance_of(LocalWorkers) 
+    it "should create a landing fleet with a ship for each host" do
+      Socket.should_receive(:gethostname).and_return("myhost")
+      options = Options.new(:ui => "DeepTest::UI::Null",
+                            :sync_options => {:source => "/my/local/dir"},
+                            :distributed_hosts => %w[host1 host2])
+
+      Distributed::RSync.should_receive(:push).with("host1", options.sync_options, "/tmp/myhost_my_local_dir")
+      Distributed::RSync.should_receive(:push).with("host2", options.sync_options, "/tmp/myhost_my_local_dir")
+
+      options.new_landing_fleet.push_code(options)
     end
 
+
     it "should return localhost as origin_hostname current hostname is same as when created" do
       options = Options.new({})
       options.origin_hostname.should == 'localhost'
@@ -150,24 +154,41 @@ module DeepTest
       options.origin_hostname.should == local_hostname
     end
 
-    it "should be able to calculate mirror_path based on base an sync_options" do
-      Socket.should_receive(:gethostname).and_return("hostname", "server_hostname")
-      options = Options.new(:sync_options => {:source => "/my/source/path"})
-      options.mirror_path("/mirror/base/path").should == 
-        "/mirror/base/path/hostname_my_source_path"
+    it "should connect_to_central_command on localhost when there is no SSH info" do
+      Telegraph::Wire.should_receive(:connect).with("localhost", 9999).and_yield(:wire)
+      yielded_wire = nil
+      Options.new(:server_port => 9999).connect_to_central_command { |yielded_wire| }
+      yielded_wire.should == :wire
+    end
+
+    it "should connect_to_central_command on remote address where there is SSH info" do
+      Telegraph::Wire.should_receive(:connect).with("remote_address", 9999).and_yield(:wire)
+      yielded_wire = nil
+
+      options = Options.new(:server_port => 9999)
+      options.ssh_client_connection_info = mock("connection_info", :address => "remote_address")
+      options.connect_to_central_command { |yielded_wire| }
+
+      yielded_wire.should == :wire
+    end
+
+    it "should be able to calculate mirror_path based on sync_options" do
+      Socket.should_receive(:gethostname).and_return("hostname")
+      options = Options.new(:sync_options => {:source => "/my/source/path", :remote_base_dir => "/mirror/base/path"})
+      options.mirror_path.should == "/mirror/base/path/hostname_my_source_path"
     end
 
     it "should raise a useful error if no source is specified" do
-      options = DeepTest::Options.new(:sync_options => {})
+      options = DeepTest::Options.new(:sync_options => {:remote_base_dir => "/mirror/base/path/"})
       lambda {
-        options.mirror_path("base")
+        options.mirror_path
       }.should raise_error("No source directory specified in sync_options")
     end
 
-    it "should create drb object to connect to server" do
-      options = DeepTest::Options.new({})
-      server = options.server
-      server.__drburi.should == "druby://#{options.origin_hostname}:#{options.server_port}"
+    it "should default to /tmp if no remote_base_dir is specified in sync_options" do
+      Socket.should_receive(:gethostname).and_return("hostname")
+      options = DeepTest::Options.new(:sync_options => {:source => "/my/source/path"})
+      options.mirror_path.should == "/tmp/hostname_my_source_path"
     end
 
     it "should be gathering metrics if metrics file is set" do

data/spec/deep_test/spec/extensions/example_methods_spec.rb

@@ -14,8 +14,9 @@ module Spec
         example_1 = group.examples.first
         example_2 = group.examples.last
 
-        example_1.identifier.locate([group]).should == example_1
-        example_2.identifier.locate([group]).should == example_2
+
+        (example_1.identifier.locate([group]) == example_1).should == true # as of rspec 1.1.12 should is redefined on examples to behave differently
+        (example_2.identifier.locate([group]) == example_2).should == true
       end
 
       it "should have identifier that can locate the example by name" do
@@ -28,8 +29,8 @@ module Spec
         example_1 = group.examples.first
         example_2 = group.examples.last
 
-        example_1.identifier.locate([group]).should == example_1
-        example_2.identifier.locate([group]).should == example_2
+        (example_1.identifier.locate([group]) == example_1).should == true
+        (example_2.identifier.locate([group]) == example_2).should == true
       end
 
       describe ExampleMethods::Identifier do

data/spec/deep_test/spec/extensions/spec_task_spec.rb

@@ -3,12 +3,11 @@ require File.dirname(__FILE__) + "/../../../spec_helper"
 describe Spec::Rake::SpecTask do
   it "should allow deep_test configuration" do
     t = Spec::Rake::SpecTask.new do |t|
-      t.deep_test :number_of_workers => 2
+      t.deep_test :number_of_agents => 2
     end
 
-    deep_test_path = File.expand_path(File.dirname(__FILE__) + 
-                                      '/../../../../lib/deep_test')
-    options = DeepTest::Options.new(:number_of_workers => 2)
+    deep_test_path = File.expand_path(DeepTest::LIB_ROOT + "/deep_test")
+    options = DeepTest::Options.new(:number_of_agents => 2)
     t.spec_opts.should == ["--require #{deep_test_path}",
                            "--runner 'DeepTest::Spec::Runner:#{options.to_command_line}'"]
   end
@@ -19,8 +18,7 @@ describe Spec::Rake::SpecTask do
       t.spec_opts = ["anoption"]
     end
 
-    deep_test_path = File.expand_path(File.dirname(__FILE__) + 
-                                      '/../../../../lib/deep_test')
+    deep_test_path = File.expand_path(DeepTest::LIB_ROOT + "/deep_test")
     options = DeepTest::Options.new({})
     t.spec_opts.should == ["--require #{deep_test_path}",
                            "--runner 'DeepTest::Spec::Runner:#{options.to_command_line}'",

data/spec/deep_test/spec/runner_spec.rb

@@ -5,100 +5,127 @@ module DeepTest
     describe Runner do
       it_should_behave_like 'sandboxed rspec_options'
 
-      it "should run each test using blackboard" do
-        blackboard = SimpleTestBlackboard.new
-        runner = Runner.new(options, Options.new({}), blackboard)
+      it "should run each test using central_command" do
+        deep_test_options = Options.new({})
+        central_command = TestCentralCommand.start deep_test_options
+        runner = Runner.new(options, deep_test_options.to_command_line)
 
         describe("test") do
           it("passes1") {}
           it("passes2") {}
         end
 
-        worker = ThreadWorker.new(blackboard, 2)
+        agent = ThreadAgent.new deep_test_options
         Timeout.timeout(5) do
-          runner.process_work_units.should == true
+          runner.process_work_units(central_command).should == true
         end
-        worker.wait_until_done
+        central_command.done_with_work
+        agent.wait_until_done
 
-        worker.work_done.should == 2
+        agent.work_done.should == 2
         options.reporter.number_of_examples.should == 2
-        blackboard.take_result.should be_nil
+        central_command.remaining_result_count.should == 0
         options.reporter.examples_finished.should == ['passes1','passes2']
         options.reporter.should be_ended
       end
 
       it "should return failure when a spec fails" do
-        blackboard = SimpleTestBlackboard.new
-        runner = Runner.new(options, Options.new({}), blackboard)
+        deep_test_options = Options.new({})
+        central_command = TestCentralCommand.start deep_test_options
+        runner = Runner.new(options, deep_test_options.to_command_line)
 
         describe("test") do
           it("passes") {}; 
           it("fails") {1.should == 2}; 
         end
 
-        worker = ThreadWorker.new(blackboard, 2)
+        agent = ThreadAgent.new(deep_test_options)
         Timeout.timeout(5) do
-          runner.process_work_units.should == false
+          runner.process_work_units(central_command).should == false
         end
-        worker.wait_until_done
+        central_command.done_with_work
+        agent.wait_until_done
       end
 
       it "should return success when there are pending examples" do
-        blackboard = SimpleTestBlackboard.new
-        runner = Runner.new(options, Options.new({}), blackboard)
+        deep_test_options = Options.new({})
+        central_command = TestCentralCommand.start deep_test_options
+        runner = Runner.new(options, deep_test_options.to_command_line)
 
         describe("test") do
           it("pending") {pending {1.should == 2}}; 
         end
 
-        worker = ThreadWorker.new(blackboard, 1)
+        agent = ThreadAgent.new deep_test_options
         Timeout.timeout(5) do
-          runner.process_work_units.should == true
+          runner.process_work_units(central_command).should == true
         end
-        worker.wait_until_done
+        central_command.done_with_work
+        agent.wait_until_done
       end
 
       it "should return failure when a pending example passes" do
-        blackboard = SimpleTestBlackboard.new
-        runner = Runner.new(options, Options.new({}), blackboard)
+        deep_test_options = Options.new({})
+        central_command = TestCentralCommand.start deep_test_options
+        runner = Runner.new(options, deep_test_options.to_command_line)
 
         describe("test") do
           it("pending") {pending {1.should == 1}}; 
         end
 
-        worker = ThreadWorker.new(blackboard, 1)
+        agent = ThreadAgent.new deep_test_options
         Timeout.timeout(5) do
-          runner.process_work_units.should == false
+          runner.process_work_units(central_command).should == false
         end
-        worker.wait_until_done
+        central_command.done_with_work
+        agent.wait_until_done
       end
 
-      it "should return failure when a worker error occurs" do
-        blackboard = SimpleTestBlackboard.new
-        runner = Runner.new(options, Options.new({}), blackboard)
+      it "should return failure when a agent error occurs" do
+        deep_test_options = Options.new({})
+        central_command = TestCentralCommand.start deep_test_options
+        runner = Runner.new(options, deep_test_options.to_command_line)
+
+        describe("test") { it("does") {} }
+
+        central_command.write_result Agent::Error.new("example", RuntimeError.new)
+        capture_stdout do
+          runner.process_work_units(central_command).should == false
+        end
+
+        options.reporter.number_of_errors.should == 1
+      end
+
+      it "should return a singl efailure when multiple agent error occurs" do
+        deep_test_options = Options.new({})
+        central_command = TestCentralCommand.start deep_test_options
+        runner = Runner.new(options, deep_test_options.to_command_line)
 
         describe("test") do
-          it("pending") {pending {1.should == 1}}; 
+          it("does a") {}
+          it("does b") {}
         end
 
-        blackboard.write_result Worker::Error.new("example", RuntimeError.new)
+        central_command.write_result Agent::Error.new("example 1", RuntimeError.new)
+        central_command.write_result Agent::Error.new("example 2", RuntimeError.new)
         capture_stdout do
-          runner.process_work_units.should == false
+          runner.process_work_units(central_command).should == false
         end
 
         options.reporter.number_of_errors.should == 1
       end
 
       it "should raise error if duplicate spec is found" do
-        blackboard = SimpleTestBlackboard.new
-        runner = Runner.new(options, Options.new({}), blackboard)
+        deep_test_options = Options.new({})
+        central_command = TestCentralCommand.start deep_test_options
+        runner = Runner.new(options, deep_test_options.to_command_line)
 
         describe("test") do
           2.times {it("example") {}}; 
         end
 
         lambda {
-          runner.process_work_units
+          runner.process_work_units(central_command)
         }.should raise_error
       end
     end