jstorimer-deep-test 1.4.0 → 2.0.0

data/spec/spec_helper.rb

@@ -1,11 +1,9 @@
 require 'rubygems'
-gem 'rspec', '=1.1.8'
+gem('rspec', ENV['RSPEC_VERSION'] || '1.1.12')
 require 'spec'
 
-require File.dirname(__FILE__) + "/../lib/deep_test"
-require File.dirname(__FILE__) + "/../test/fake_deadlock_error"
-require File.dirname(__FILE__) + "/../test/simple_test_blackboard"
-require File.dirname(__FILE__) + "/thread_worker"
+require File.dirname(__FILE__) + '/../lib/deep_test'
+require File.dirname(__FILE__) + "/../infrastructure/load"
 
 describe "sandboxed rspec_options", :shared => true do
   attr_reader :options
@@ -17,8 +15,18 @@ describe "sandboxed rspec_options", :shared => true do
     ::Spec::Runner.use @options
   end
 
+  after(:each) { ::Spec::Runner.use @original_rspec_options }
+
+  before(:each) { DynamicTeardown.setup }
+  after(:each) { DynamicTeardown.teardown }
+
+  before(:each) do
+    @old_logger = DeepTest.logger
+    DeepTest.logger = TestLogger.new
+  end
+
   after(:each) do
-    ::Spec::Runner.use @original_rspec_options
+    DeepTest.logger = @old_logger if @old_logger
   end
 
   class FakeReporter

data/test/deep_test/agent_test.rb

@@ -0,0 +1,175 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "puts result on central_command with acknowledgement of work" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start options
+      central_command.write_work Test::WorkUnit.new(TestFactory.passing_test)
+      central_command.done_with_work
+
+      Agent.new(0, options, stub_everything).execute(StringIO.new, StringIO.new)
+
+      assert_equal [], central_command.switchboard.live_wires.first.unacked_messages
+      assert_kind_of ::Test::Unit::TestResult, central_command.take_result
+    end
+
+    test "puts passing and failing tests on central_command for each test" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start options
+      central_command.write_work Test::WorkUnit.new(TestFactory.passing_test)
+      central_command.write_work Test::WorkUnit.new(TestFactory.failing_test)
+      central_command.done_with_work
+
+      Agent.new(0, options, stub_everything).execute(StringIO.new, StringIO.new)
+
+      result_1 = central_command.take_result
+      result_2 = central_command.take_result
+
+      assert_equal true, (result_1.passed? || result_2.passed?)
+      assert_equal false, (result_1.passed? && result_2.passed?)
+    end
+
+    test "notifies listener that it is starting" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start options
+      central_command.done_with_work
+      listener = stub_everything
+      agent = Agent.new(0, options, listener)
+      listener.expects(:starting).with(agent)
+      agent.execute(StringIO.new, StringIO.new)
+    end
+
+    test "notifies listener that it is about to do work" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start options
+      work_unit = Test::WorkUnit.new(TestFactory.passing_test)
+      central_command.write_work work_unit
+      central_command.done_with_work
+      listener = stub_everything
+      agent = Agent.new(0, options, listener)
+      listener.expects(:starting_work).with(agent, work_unit)
+      agent.execute(StringIO.new, StringIO.new)
+    end
+
+    test "notifies listener that it has done work" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start(options)
+      work_unit = ResultWorkUnit.new(:result)
+      central_command.write_work work_unit
+      central_command.done_with_work
+      listener = stub_everything
+      agent = Agent.new(0, options, listener)
+      listener.expects(:finished_work).with(agent, work_unit, TestResult.new(:result))
+      agent.execute(StringIO.new, StringIO.new)
+    end
+
+    test "connect indicates it has connected" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start(options)
+      agent = Agent.new(0, options, stub_everything)
+      yielded = false
+      agent.connect(io = StringIO.new) do
+        yielded = true
+        assert_equal "Connected\n", io.string
+        assert_equal true, io.closed?
+      end
+      assert yielded, "connect didn't yield"
+    end
+
+    test "connect closes stream even if there is an error" do
+      options = Options.new({})
+      agent = Agent.new(0, options, stub_everything)
+      io = StringIO.new
+      assert_raises(Errno::EADDRNOTAVAIL) { agent.connect io }
+      assert_equal true, io.closed?
+    end
+
+    class ResultWorkUnit
+      attr_reader :result
+
+      def initialize(result)
+        @result = result
+      end
+
+      def run
+        TestResult.new(result)
+      end
+
+      def ==(other)
+        other.class == self.class && other.result == result
+      end
+    end
+
+    class ErrorWorkUnit
+      attr_reader :exception
+
+      def initialize(exception)
+        @exception = exception
+      end
+
+      def run
+        raise @exception
+      end
+
+      def ==(other)
+        other.class == self.class && other.exception == exception
+      end
+    end
+
+    test "exception raised by work unit gives in Agent::Error" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start options
+      work_unit = ErrorWorkUnit.new(exception = TestException.new)
+      central_command.write_work work_unit
+      central_command.done_with_work
+
+      Agent.new(0, options, stub_everything).execute(StringIO.new, StringIO.new)
+      
+      assert_equal Agent::Error.new(work_unit, exception), central_command.take_result
+    end
+
+    test "Agent::Error can marshal itself even if the contents are not marshallable" do
+      o = Object.new
+      def o._dump; raise "error"; end
+
+      error = Agent::Error.new o, Exception.new("my error")
+      error_through_marshalling = Marshal.load Marshal.dump(error)
+      assert_equal Exception, error_through_marshalling.error.class
+      assert_equal "my error", error_through_marshalling.error.message
+      assert_equal "<< Undumpable >>", error_through_marshalling.work_unit
+    end
+
+    test "requests work until it finds some" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start(options)
+
+      t = Thread.new { Agent.new(0, options, stub_everything).execute(StringIO.new, StringIO.new) }
+      Thread.pass
+      central_command.write_work stub(:run => TestResult.new(:result))
+      central_command.done_with_work
+      t.join
+      assert_equal TestResult.new(:result), central_command.take_result
+    end
+
+    test "finish running if a connection error is received" do
+      options = Options.new({})
+      central_command = TestCentralCommand.start(options)
+      begin
+        t = Thread.new { Agent.new(0, options, stub_everything).execute(StringIO.new, StringIO.new) }
+        sleep 0.1
+      ensure
+        central_command.stop
+      end
+      t.join
+    end
+
+    test "number is available to indentify agent" do
+      assert_equal 1, Agent.new(1, Options.new({}), nil).number
+    end
+    
+    test "does not fork from rake" do
+      assert !defined?($rakefile)
+    end
+  end
+end

data/test/deep_test/central_command_test.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "take_work returns result of push_work when it is available" do
+      central_command = CentralCommand.new Options.new({})
+      central_command.write_work :work
+      assert_equal :work, central_command.take_work
+    end
+
+    test "take_work raises error when no work is currently available" do
+      assert_raises(CentralCommand::NoWorkUnitsAvailableError) do
+        CentralCommand.new(Options.new({})).take_work
+      end
+    end
+
+    test "take_work raises error when there is no work left to" do
+      central_command = CentralCommand.new Options.new({})
+      central_command.done_with_work
+
+      assert_raises(CentralCommand::NoWorkUnitsRemainingError) do
+        central_command.take_work
+      end
+    end
+
+    test "take_result raises NoAgentsRunningError if agents are connected" do
+      central_command = CentralCommand.start Options.new({}) 
+      DynamicTeardown.on_teardown { central_command.stop }
+      assert_raises(CentralCommand::NoAgentsRunningError) {central_command.take_result}
+    end
+    
+    test "start returns instance of central_command" do
+      central_command = CentralCommand.start Options.new({})
+      DynamicTeardown.on_teardown { central_command.stop }
+      assert_kind_of CentralCommand, central_command
+    end
+
+    test "after starting CentralCommand responds to NeedWork messages by supplying new units of work" do
+      central_command = CentralCommand.start(options = Options.new({}))
+      DynamicTeardown.on_teardown { central_command.stop }
+      central_command.write_work(:a)
+      central_command.write_work(:b)
+      central_command.write_work(:c)
+
+      wire = Telegraph::Wire.connect("localhost", options.server_port)
+      [:a, :b, :c].each do |work_unit|
+        Thread.pass
+        wire.send_message CentralCommand::NeedWork
+        assert_equal work_unit, wire.next_message(:timeout => 2.0).body
+      end
+    end
+
+    test "after starting CentralCommand responds to Result messages adding results to the queue" do
+      central_command = CentralCommand.start(options = Options.new({}))
+      DynamicTeardown.on_teardown { central_command.stop }
+      wire = Telegraph::Wire.connect("localhost", options.server_port)
+      result_1, result_2, result_3 = TestResult.new(1), TestResult.new(2), TestResult.new(3)
+
+      [result_1, result_2, result_3].each do |result|
+        wire.send_message result
+      end
+
+      assert_equal result_1, central_command.take_result
+      assert_equal result_2, central_command.take_result
+      assert_equal result_3, central_command.take_result
+    end
+
+    test "after starting CentralCommand responds to Result by supplying a new unit of work" do
+      central_command = CentralCommand.start(options = Options.new({}))
+      DynamicTeardown.on_teardown { central_command.stop }
+      central_command.write_work(:a)
+      central_command.write_work(:b)
+      central_command.write_work(:c)
+
+      wire = Telegraph::Wire.connect("localhost", options.server_port)
+      result_1, result_2, result_3 = TestResult.new(1), TestResult.new(2), TestResult.new(3)
+      [[result_1, :a], [result_2, :b], [result_3, :c]].each do |result, work_unit|
+        Thread.pass
+        wire.send_message result_1
+        assert_equal work_unit, wire.next_message(:timeout => 2.0).body
+      end
+    end
+
+    test "will add results to queue with a worker waiting for work that is not available" do
+      central_command = CentralCommand.start(options = Options.new({}))
+      DynamicTeardown.on_teardown { central_command.stop }
+
+      Telegraph::Wire.connect("localhost", options.server_port) do |wire|
+        wire.send_message CentralCommand::NeedWork
+        wire.send_message TestResult.new(1)
+      end
+
+      assert_equal TestResult.new(1), central_command.take_result
+    end
+
+    test "will distribute work units that have not received results from dead workers when other work runs out" do
+      central_command = CentralCommand.start(options = Options.new({}))
+      DynamicTeardown.on_teardown { central_command.stop }
+
+      central_command.write_work(:a)
+
+      Telegraph::Wire.connect("localhost", options.server_port) do |wire|
+        wire.send_message CentralCommand::NeedWork
+        assert_equal :a, wire.next_message(:timeout => 1).body
+      end
+
+      Telegraph::Wire.connect("localhost", options.server_port) do |wire|
+        wire.send_message CentralCommand::NeedWork
+        assert_equal :a, wire.next_message(:timeout => 1).body
+      end
+    end
+
+    test "will add measurements to data when received over the wire" do
+      central_command = CentralCommand.start(options = Options.new({}))
+      DynamicTeardown.on_teardown { central_command.stop }
+
+      Telegraph::Wire.connect("localhost", options.server_port) do |wire|
+        wire.send_message Metrics::Measurement.new("category", 1, "units")
+      end
+
+      sleep 0.05
+
+      assert_match /category: 1.0 avg/, central_command.data.summary
+    end
+
+    class SetCalledGlobalToTrue
+      include CentralCommand::Operation
+      def execute; $called = true; end
+    end
+
+    test "will execute Operations read from the wire" do
+      $called = false
+      DynamicTeardown.on_teardown { $called = nil }
+      central_command = CentralCommand.start(options = Options.new({}))
+      DynamicTeardown.on_teardown { central_command.stop }
+      wire = Telegraph::Wire.connect("localhost", options.server_port)
+      wire.send_message SetCalledGlobalToTrue.new
+
+      Timeout.timeout(2) do
+        loop do
+          break if $called
+          sleep 0.25
+        end
+      end
+    end
+  end
+end

data/test/deep_test/cpu_info_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "count parses sysctl output on darwin" do
+      cpu_info = CpuInfo.new("foodarwinbar")
+      cpu_info.expects(:`).with("sysctl -n hw.ncpu").returns("2\n")
+      assert_equal 2, cpu_info.count
+    end
+
+    test "count parses /proc/cpuinfo on linux" do
+      cpu_info = CpuInfo.new("foolinuxbar")
+      File.expects(:readlines).with("/proc/cpuinfo").returns [
+        "processor	: 0",
+        "vendor_id	: GenuineIntel",
+        "cpu family	: 6",
+        "",
+        "processor	: 1",
+        "vendor_id	: GenuineIntel",
+        "cpu family	: 6",
+      ]
+      assert_equal 2, cpu_info.count
+    end
+
+    test "count returns nil on other platforms" do
+      assert_equal nil, CpuInfo.new("foobar").count
+    end
+
+    test "platform defaults to the current ruby_platform" do
+      assert_equal RUBY_PLATFORM, CpuInfo.new.platform
+    end
+  end
+end

data/test/deep_test/database/mysql_setup_listener_test.rb

@@ -1,14 +1,18 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-unit_tests do
-  test "dump_schema includes procedures" do
-    listener = DeepTest::Database::MysqlSetupListener.new
-    listener.expects(:system).with do |command|
-      command =~ / -R /
+module DeepTest
+  module Database
+    unit_tests do
+      test "dump_schema includes procedures" do
+        listener = MysqlSetupListener.new
+        listener.expects(:system).with do |command|
+          command =~ / -R /
+        end
+        listener.expects(:master_database_config).returns({})
+        listener.expects(:dump_file_name).returns("")
+        $?.expects(:success?).returns(true)
+        listener.dump_schema
+      end
     end
-    listener.expects(:master_database_config).returns({})
-    listener.expects(:dump_file_name).returns("")
-    $?.expects(:success?).returns(true)
-    listener.dump_schema
   end
 end

data/test/deep_test/demon_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+module DeepTest
+  unit_tests do
+    class ProcDemon
+      include Demon
+      def initialize(block); @block = block; end
+      def execute; @block.call; end
+    end
+
+    test "forked redirects output back to central command" do
+      options = Options.new({})
+      operator = TestOperator.listen(options)
+      ProcDemon.new(proc do
+        puts "hello stdout"
+      end).forked("name", options, [])
+
+      assert_equal ProxyIO::Stdout::Output.new("hello stdout"), operator.next_message[0].body
+      assert_equal ProxyIO::Stdout::Output.new("\n"), operator.next_message[0].body
+    end
+  end
+end
+

data/test/deep_test/distributed/beachhead_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "load_files loads each file in list, resolving each filename with resolver" do
+        FilenameResolver.expects(:new).with("/mirror/dir").returns(resolver = mock)
+
+        beachhead = Beachhead.new "/mirror/dir", Options.new({})
+
+        resolver.expects(:resolve).with("/source/path/my/file.rb").returns("/mirror/dir/my/file.rb")
+        beachhead.expects(:load).with("/mirror/dir/my/file.rb")
+        Dir.expects(:chdir).with("/mirror/dir")
+
+        beachhead.load_files(["/source/path/my/file.rb"])
+      end
+
+      test "service is removed after grace period if agents have not been started" do
+        options = Options.new({:number_of_agents => 0})
+        TestCentralCommand.start options
+        begin
+          beachhead = Beachhead.new "", options
+          beachhead.daemonize(0.25)
+          # Have to sleep long enough to warlock to reap dead process
+          sleep 2.0
+          assert_equal 0, beachhead.warlock.demon_count
+        ensure
+          beachhead.warlock.stop_demons
+        end
+      end
+
+      test "service is not removed after grace period if agents have been started" do
+        options = Options.new({:number_of_agents => 0})
+        TestCentralCommand.start options
+        begin
+          beachhead = Beachhead.new "", options
+          # Since we're not actually starting agents, we don't want to exit when none are running for this test
+          beachhead.warlock.stubs(:exit_when_none_running)
+          port = beachhead.daemonize(0.25)
+          Telegraph::Wire.connect("localhost", port).send_message Beachhead::DeployAgents
+          # Have to sleep long enough to warlock to reap dead process
+          sleep 1.0
+          assert_equal 1, beachhead.warlock.demon_count
+        ensure
+          beachhead.warlock.stop_demons
+        end
+      end
+
+      test "responds with Done after receiving LoadFiles and DeployAgents" do
+        options = Options.new({:number_of_agents => 0})
+        TestCentralCommand.start options
+        begin
+          beachhead = Beachhead.new File.dirname(__FILE__), options
+          # Since we're not actually starting agents, we don't want to exit when none are running for this test
+          beachhead.warlock.stubs(:exit_when_none_running)
+          port = beachhead.daemonize(0.25)
+          wire = Telegraph::Wire.connect("localhost", port)
+          wire.send_message Beachhead::LoadFiles.new([])
+          wire.send_message Beachhead::DeployAgents
+          assert_equal Beachhead::Done, wire.next_message(:timeout => 1).body
+        ensure
+          beachhead.warlock.stop_demons
+        end
+      end
+    end
+  end
+end