jstorimer-deep-test 0.2.0 → 1.0.0

data/negative_acceptance_tests/tests.rb

@@ -1,60 +0,0 @@
-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/test/deep_test/agent_test.rb

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

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

@@ -1,33 +0,0 @@
-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/demon_test.rb

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

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