jstorimer-deep-test 0.2.0 → 1.0.0

data/spec/deep_test/option_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module DeepTest
+  describe Option do
+    it "should have hash conversion" do
+      option = Option.new(:name, Option::Hash, {})
+      string = option.to_command_line({:a => "1", :b => "a"})
+      string.should be_instance_of(String)
+      option.from_command_line(string).should == {:a => "1", :b => "a"}
+    end
+
+    it "should support booleans in hash" do
+      option = Option.new(:name, Option::Hash, {})
+      string = option.to_command_line({:a => true})
+      string.should be_instance_of(String)
+      option.from_command_line(string).should == {:a => true}
+    end
+
+    it "should handle hash values with spaces" do
+      option = Option.new(:name, Option::Hash, {})
+
+      string = option.to_command_line(
+        {:a => "has a space", :b => "has more spaces"}
+      )
+
+      string.should be_instance_of(String)
+
+      option.from_command_line(string).should == 
+        {:a => "has a space", :b => "has more spaces"}
+    end
+  end
+end
+

data/spec/deep_test/options_spec.rb

@@ -2,55 +2,59 @@ require File.dirname(__FILE__) + "/../spec_helper"
 
 module DeepTest
   describe Options do
-    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
+    it "should support number_of_workers" do
+      Options.new(:number_of_workers => 3).number_of_workers.should == 3
     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_hosts" do
-      Options.new(:distributed_hosts => %w[host1 host2]).
-        distributed_hosts.should == %w[host1 host2]
+    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
     end
 
     it "should support sync_options" do
       Options.new(:sync_options => {:options => 1}).sync_options.should == {:options => 1}
     end
 
-    it "should support listener" do
-      Options.new(:listener => "AListener").
-        listener.should == "AListener"
+    it "should support worker_listener" do
+      Options.new(:worker_listener => "AListener").
+        worker_listener.should == "AListener"
     end
 
-    it "should use DeepTest::NullListener as the default listener" do
-      Options.new({}).listener.should == "DeepTest::NullListener"
+    it "should use DeepTest::NullWorkerListener as the default listener" do
+      Options.new({}).worker_listener.should == "DeepTest::NullWorkerListener"
     end
     
-    it "should allow listener to be set with class" do
+    it "should allow worker_listener to be set with class" do
       class FakeListener; end
-      Options.new(:listener => FakeListener).
-        listener.should == "DeepTest::FakeListener"
+      Options.new(:worker_listener => FakeListener).
+        worker_listener.should == "DeepTest::FakeListener"
     end
 
-    it "should allow multiple listeners to be specified" do
+    it "should allow multiple workers to be specified" do
       class FakeListener1; end
       class FakeListener2; end
       options = Options.new(
-        :listener => "DeepTest::FakeListener1,DeepTest::FakeListener2"
+        :worker_listener => "DeepTest::FakeListener1,DeepTest::FakeListener2"
       )
       listener = options.new_listener_list
       listener.should be_instance_of(DeepTest::ListenerList)
@@ -59,7 +63,7 @@ module DeepTest
       listener.listeners.last.should be_instance_of(FakeListener2)
     end
 
-    it "should create a list of agent listeners upon request" do
+    it "should create a list of worker listeners upon request" do
       Options.new({}).new_listener_list.should be_instance_of(DeepTest::ListenerList)
     end
 
@@ -88,7 +92,7 @@ module DeepTest
     end
 
     it "should support strings as well as symbols" do
-      Options.new("server_port" => 2).server_port.should == 2
+      Options.new("number_of_workers" => 2).number_of_workers.should == 2
     end
 
     it "should raise error when invalid option is specifed" do
@@ -98,50 +102,42 @@ module DeepTest
     end
 
     it "should convert to command line option string" do
-      options = Options.new(:number_of_agents => 1)
-      options.to_command_line.should == Base64.encode64(Marshal.dump(options)).gsub("\n","")
+      options = Options.new(:number_of_workers => 1, :timeout_in_seconds => 3)
+      options.to_command_line.should == 
+        "--number_of_workers 1 --timeout_in_seconds 3"
     end
 
     it "should parse from command line option string" do
-      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 == '*'
+      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 == '*'
     end
 
     it "should use default option value when no command line option is present" do
-      ["", nil].each do |blank_value|
-        options = Options.from_command_line(blank_value)
-        options.ui == "DeepTest::UI::Console"
-      end
+      options = Options.from_command_line("")
+      options.number_of_workers.should == 2
     end
 
-    it "should create local deployment by default" do
+    it "should create local workers by default" do
       options = Options.new({})
-      options.new_deployment.should be_instance_of(LocalDeployment) 
+      options.new_workers.should be_instance_of(LocalWorkers) 
     end
 
-    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
+    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
     end
 
-    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)
+    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) 
     end
 
-
     it "should return localhost as origin_hostname current hostname is same as when created" do
       options = Options.new({})
       options.origin_hostname.should == 'localhost'
@@ -154,41 +150,24 @@ module DeepTest
       options.origin_hostname.should == local_hostname
     end
 
-    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"
+    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"
     end
 
     it "should raise a useful error if no source is specified" do
-      options = DeepTest::Options.new(:sync_options => {:remote_base_dir => "/mirror/base/path/"})
+      options = DeepTest::Options.new(:sync_options => {})
       lambda {
-        options.mirror_path
+        options.mirror_path("base")
       }.should raise_error("No source directory specified in sync_options")
     end
 
-    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"
+    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}"
     end
 
     it "should be gathering metrics if metrics file is set" do

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

@@ -14,9 +14,8 @@ module Spec
         example_1 = group.examples.first
         example_2 = group.examples.last
 
-
-        (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
+        example_1.identifier.locate([group]).should == example_1
+        example_2.identifier.locate([group]).should == example_2
       end
 
       it "should have identifier that can locate the example by name" do
@@ -29,8 +28,8 @@ module Spec
         example_1 = group.examples.first
         example_2 = group.examples.last
 
-        (example_1.identifier.locate([group]) == example_1).should == true
-        (example_2.identifier.locate([group]) == example_2).should == true
+        example_1.identifier.locate([group]).should == example_1
+        example_2.identifier.locate([group]).should == example_2
       end
 
       describe ExampleMethods::Identifier do

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

@@ -3,11 +3,12 @@ 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_agents => 2
+      t.deep_test :number_of_workers => 2
     end
 
-    deep_test_path = File.expand_path(DeepTest::LIB_ROOT + "/deep_test")
-    options = DeepTest::Options.new(:number_of_agents => 2)
+    deep_test_path = File.expand_path(File.dirname(__FILE__) + 
+                                      '/../../../../lib/deep_test')
+    options = DeepTest::Options.new(:number_of_workers => 2)
     t.spec_opts.should == ["--require #{deep_test_path}",
                            "--runner 'DeepTest::Spec::Runner:#{options.to_command_line}'"]
   end
@@ -18,7 +19,8 @@ describe Spec::Rake::SpecTask do
       t.spec_opts = ["anoption"]
     end
 
-    deep_test_path = File.expand_path(DeepTest::LIB_ROOT + "/deep_test")
+    deep_test_path = File.expand_path(File.dirname(__FILE__) + 
+                                      '/../../../../lib/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,127 +5,100 @@ module DeepTest
     describe Runner do
       it_should_behave_like 'sandboxed rspec_options'
 
-      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)
+      it "should run each test using blackboard" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
 
         describe("test") do
           it("passes1") {}
           it("passes2") {}
         end
 
-        agent = ThreadAgent.new deep_test_options
+        worker = ThreadWorker.new(blackboard, 2)
         Timeout.timeout(5) do
-          runner.process_work_units(central_command).should == true
+          runner.process_work_units.should == true
         end
-        central_command.done_with_work
-        agent.wait_until_done
+        worker.wait_until_done
 
-        agent.work_done.should == 2
+        worker.work_done.should == 2
         options.reporter.number_of_examples.should == 2
-        central_command.remaining_result_count.should == 0
+        blackboard.take_result.should be_nil
         options.reporter.examples_finished.should == ['passes1','passes2']
         options.reporter.should be_ended
       end
 
       it "should return failure when a spec fails" do
-        deep_test_options = Options.new({})
-        central_command = TestCentralCommand.start deep_test_options
-        runner = Runner.new(options, deep_test_options.to_command_line)
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
 
         describe("test") do
           it("passes") {}; 
           it("fails") {1.should == 2}; 
         end
 
-        agent = ThreadAgent.new(deep_test_options)
+        worker = ThreadWorker.new(blackboard, 2)
         Timeout.timeout(5) do
-          runner.process_work_units(central_command).should == false
+          runner.process_work_units.should == false
         end
-        central_command.done_with_work
-        agent.wait_until_done
+        worker.wait_until_done
       end
 
       it "should return success when there are pending examples" do
-        deep_test_options = Options.new({})
-        central_command = TestCentralCommand.start deep_test_options
-        runner = Runner.new(options, deep_test_options.to_command_line)
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
 
         describe("test") do
           it("pending") {pending {1.should == 2}}; 
         end
 
-        agent = ThreadAgent.new deep_test_options
+        worker = ThreadWorker.new(blackboard, 1)
         Timeout.timeout(5) do
-          runner.process_work_units(central_command).should == true
+          runner.process_work_units.should == true
         end
-        central_command.done_with_work
-        agent.wait_until_done
+        worker.wait_until_done
       end
 
       it "should return failure when a pending example passes" do
-        deep_test_options = Options.new({})
-        central_command = TestCentralCommand.start deep_test_options
-        runner = Runner.new(options, deep_test_options.to_command_line)
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
 
         describe("test") do
           it("pending") {pending {1.should == 1}}; 
         end
 
-        agent = ThreadAgent.new deep_test_options
+        worker = ThreadWorker.new(blackboard, 1)
         Timeout.timeout(5) do
-          runner.process_work_units(central_command).should == false
+          runner.process_work_units.should == false
         end
-        central_command.done_with_work
-        agent.wait_until_done
+        worker.wait_until_done
       end
 
-      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)
+      it "should return failure when a worker error occurs" do
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
 
         describe("test") do
-          it("does a") {}
-          it("does b") {}
+          it("pending") {pending {1.should == 1}}; 
         end
 
-        central_command.write_result Agent::Error.new("example 1", RuntimeError.new)
-        central_command.write_result Agent::Error.new("example 2", RuntimeError.new)
+        blackboard.write_result Worker::Error.new("example", RuntimeError.new)
         capture_stdout do
-          runner.process_work_units(central_command).should == false
+          runner.process_work_units.should == false
         end
 
         options.reporter.number_of_errors.should == 1
       end
 
       it "should raise error if duplicate spec is found" do
-        deep_test_options = Options.new({})
-        central_command = TestCentralCommand.start deep_test_options
-        runner = Runner.new(options, deep_test_options.to_command_line)
+        blackboard = SimpleTestBlackboard.new
+        runner = Runner.new(options, Options.new({}), blackboard)
 
         describe("test") do
           2.times {it("example") {}}; 
         end
 
         lambda {
-          runner.process_work_units(central_command)
+          runner.process_work_units
         }.should raise_error
       end
     end