jstorimer-deep-test 0.2.0 → 1.0.0

data/test/deep_test/ui/console_test.rb

@@ -1,13 +1,9 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-module DeepTest
-  module UI
-    unit_tests do
-      test "dispatch_finished doesn't fail if spinner is nil" do
-        assert_nothing_raised do
-          Console.new(:options).dispatch_finished(:method_name)
-        end
-      end
+unit_tests do
+  test "dispatch_finished doesn't fail if spinner is nil" do
+    assert_nothing_raised do
+      DeepTest::UI::Console.new(:options).dispatch_finished(:method_name)
     end
   end
 end

data/test/deep_test/warlock_test.rb

@@ -1,40 +1,38 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
-module DeepTest
-  unit_tests do
-    test "running? is true if sending kill(0, pid) does not fail" do
-      warlock = Warlock.new Options.new({})
-      Process.expects(:kill).with(0, :pid)
-      assert_equal true, warlock.running?(:pid)
-    end
-    
-    test "running? is false if Process.kill(0, pid) raises Errno::ESRCH" do
-      warlock = Warlock.new Options.new({})
-      Process.stubs(:kill).raises(Errno::ESRCH)
-      assert_equal false, warlock.running?(:pid)
-    end
-    
-    test "running? is true if Process.kill raises Exception" do
-      warlock = Warlock.new Options.new({})
-      Process.stubs(:kill).raises(Exception)
-      assert_equal true, warlock.running?(:pid)
-    end
+unit_tests do
+  test "running? is true if sending kill(0, pid) does not fail" do
+    warlock = DeepTest::Warlock.new
+    Process.expects(:kill).with(0, :pid)
+    assert_equal true, warlock.running?(:pid)
+  end
+  
+  test "running? is false if Process.kill(0, pid) raises Errno::ESRCH" do
+    warlock = DeepTest::Warlock.new
+    Process.stubs(:kill).raises(Errno::ESRCH)
+    assert_equal false, warlock.running?(:pid)
+  end
+  
+  test "running? is true if Process.kill raises Exception" do
+    warlock = DeepTest::Warlock.new
+    Process.stubs(:kill).raises(Exception)
+    assert_equal true, warlock.running?(:pid)
+  end
 
-    test "demon_count is 0 initially" do
-      assert_equal 0, Warlock.new(Options.new({})).demon_count
-    end
+  test "demon_count is 0 initially" do
+    assert_equal 0, DeepTest::Warlock.new.demon_count
+  end
 
-    test "add_demon increases demon_count by 1" do
-      warlock = Warlock.new Options.new({})
-      warlock.send(:add_demon, "name", 1)
-      assert_equal 1, warlock.demon_count
-    end
+  test "add_demon increases demon_count by 1" do
+    warlock = DeepTest::Warlock.new
+    warlock.send(:add_demon, "name", 1)
+    assert_equal 1, warlock.demon_count
+  end
 
-    test "remove_demon increases demon_count by 1" do
-      warlock = Warlock.new Options.new({})
-      warlock.send(:add_demon, "name", 1)
-      warlock.send(:remove_demon, "name", 1)
-      assert_equal 0, warlock.demon_count
-    end
+  test "remove_demon increases demon_count by 1" do
+    warlock = DeepTest::Warlock.new
+    warlock.send(:add_demon, "name", 1)
+    warlock.send(:remove_demon, "name", 1)
+    assert_equal 0, warlock.demon_count
   end
 end

data/test/deep_test/worker_test.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "puts result on blackboard" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_work DeepTest::Test::WorkUnit.new(TestFactory.passing_test)
+
+    DeepTest::Worker.new(0, blackboard,stub_everything).run
+
+    assert_kind_of Test::Unit::TestResult, blackboard.take_result
+  end
+
+  test "puts passing and failing tests on blackboard for each test" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_work DeepTest::Test::WorkUnit.new(TestFactory.passing_test)
+    blackboard.write_work DeepTest::Test::WorkUnit.new(TestFactory.failing_test)
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).run
+
+    result_1 = blackboard.take_result
+    result_2 = blackboard.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
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    listener = stub_everything
+    worker = DeepTest::Worker.new(0, blackboard, listener)
+    listener.expects(:starting).with(worker)
+    worker.run
+  end
+
+  test "notifies listener that it is about to do work" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    work_unit = DeepTest::Test::WorkUnit.new(TestFactory.passing_test)
+    blackboard.write_work work_unit
+    listener = stub_everything
+    worker = DeepTest::Worker.new(0, blackboard, listener)
+    listener.expects(:starting_work).with(worker, work_unit)
+    worker.run
+  end
+
+  test "notifies listener that it has done work" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    work_unit = mock(:run => :result)
+    blackboard.write_work work_unit
+    listener = stub_everything
+    worker = DeepTest::Worker.new(0, blackboard, listener)
+    listener.expects(:finished_work).with(worker, work_unit, :result)
+    worker.run
+  end
+
+  test "exception raised by work unit gives in Worker::Error" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    work_unit = mock
+    work_unit.expects(:run).raises(exception = RuntimeError.new)
+    blackboard.write_work work_unit
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).run
+    
+    assert_equal DeepTest::Worker::Error.new(work_unit, exception),
+                 blackboard.take_result
+  end
+
+  test "requests work until it finds some" do
+    blackboard = mock
+    blackboard.expects(:take_work).times(3).
+      raises(DeepTest::Server::NoWorkUnitsAvailableError).
+      returns(work_unit = mock(:run => nil)).
+      returns(nil)
+
+    blackboard.expects(:write_result)
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).run
+  end
+
+  test "finishes running when no more work units are remaining" do
+    blackboard = mock
+    blackboard.expects(:take_work).
+      raises(DeepTest::Server::NoWorkUnitsRemainingError)
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).run
+  end
+
+  test "number is available to indentify worker" do
+    assert_equal 1, DeepTest::Worker.new(1, nil, nil).number
+  end
+  
+  test "does not fork from rake" do
+    assert !defined?($rakefile)
+  end
+end

data/test/failing.rake

@@ -0,0 +1,11 @@
+require 'rake'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "deep_test"
+require "deep_test/rake_tasks"
+
+task :default => %w[deep_test_failing]
+
+DeepTest::TestTask.new :deep_test_failing do |t|
+  t.number_of_workers = 1
+  t.pattern = "test/failing.rb"
+end

data/{negative_acceptance_tests/failing_test.rb → test/failing.rb}

@@ -1,6 +1,4 @@
-require 'rubygems'
-require 'test/unit'
-require 'dust'
+require File.dirname(__FILE__) + "/test_helper"
 
 unit_tests do
   test "failing" do

data/test/simple_test_blackboard.rb

@@ -0,0 +1,45 @@
+module DeepTest
+  class SimpleTestBlackboard
+    attr_accessor :debug, :simulate_result_overdue_error
+
+    def initialize
+      @work_units = []
+      @test_results = []
+      @semaphore = Mutex.new
+    end
+
+    def take_result
+      raise DeepTest::Server::ResultOverdueError if @simulate_result_overdue_error
+      @semaphore.synchronize do
+        log_and_return "take_result", @test_results.shift
+      end
+    end
+
+    def take_work
+      @semaphore.synchronize do
+        log_and_return "take_work", @work_units.shift
+      end
+    end
+
+    def write_result(result)
+      @semaphore.synchronize do
+        log_and_return "write_result", result
+        @test_results.push result
+      end
+    end
+
+    def write_work(work_unit)
+      @semaphore.synchronize do
+        log_and_return "write_work", work_unit
+        @work_units.push work_unit
+      end
+    end
+
+    def log_and_return(message, object)
+      if debug && object
+        puts "* #{message} #{object.inspect}"
+      end
+      object
+    end
+  end
+end

data/test/simple_test_blackboard_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "a test that is put on can be taken off later" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    test_case = TestFactory.passing_test
+    blackboard.write_work test_case
+    assert_equal test_case, blackboard.take_work
+  end
+
+  test "taking a test when all have been taken returns nil" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    test_case = TestFactory.passing_test
+    blackboard.write_work test_case
+    blackboard.take_work
+    assert_nil blackboard.take_work
+  end
+
+  test "a result that is put on can be taken off later" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    result = TestFactory.passed_result
+    blackboard.write_result result
+    assert_equal result, blackboard.take_result
+  end
+
+  test "taking a result when all have been taken returns nil" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    result = TestFactory.passed_result
+    blackboard.write_result result
+    blackboard.take_result
+    assert_nil blackboard.take_result
+  end
+end

data/test/test_helper.rb

@@ -2,29 +2,14 @@ require 'rubygems'
 require 'test/unit'
 require 'dust'
 require 'mocha'
-require 'set'
-
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
 require "deep_test"
+require 'set'
 
-require File.dirname(__FILE__) + "/../infrastructure/load"
+require File.dirname(__FILE__) + "/fake_deadlock_error"
+require File.dirname(__FILE__) + "/simple_test_blackboard"
+require File.dirname(__FILE__) + "/test_factory"
+require File.dirname(__FILE__) + "/../spec/thread_worker"
 
 class SomeCustomException < RuntimeError
 end
-
-class Test::Unit::TestCase
-  def setup
-    @old_logger = DeepTest.logger
-    DeepTest.logger = TestLogger.new
-    DynamicTeardown.setup
-  end
-
-  def teardown
-    DeepTest.logger = @old_logger if @old_logger
-    DynamicTeardown.teardown
-  end
-
-  def at(time, &block)
-    Timewarp.freeze(time, &block)
-  end
-end

data/test/test_task_test.rb

@@ -1,75 +1,72 @@
 require File.dirname(__FILE__) + "/test_helper"
 
-module DeepTest
-  unit_tests do
-    test "defines a rake task with the name passed to the constructor" do
-      TestTask.any_instance.stubs(:desc)
-      TestTask.any_instance.expects(:task).with(:my_task_name)
-      TestTask.new :my_task_name do
-      end
+unit_tests do
+  test "defines a rake task with the name passed to the constructor" do
+    DeepTest::TestTask.any_instance.stubs(:desc)
+    DeepTest::TestTask.any_instance.expects(:task).with(:my_task_name)
+    DeepTest::TestTask.new :my_task_name do
     end
-    
-    test "setting pattern" do
-      pattern = "test/**/x*_test.rb"
-      task = TestTask.new do |t|
-        t.stubs(:define)
-        t.pattern = pattern
-      end
-      assert_equal pattern, task.pattern[-pattern.size..-1]
+  end
+  
+  test "setting pattern" do
+    pattern = "test/**/x*_test.rb"
+    task = DeepTest::TestTask.new do |t|
+      t.stubs(:define)
+      t.pattern = pattern
     end
-    
-    test "default pattern is test/**/*_test.rb" do
-      task = TestTask.new do |t|
-        t.stubs(:define)
-      end
-      assert_equal "test/**/*_test.rb", task.pattern[-"test/**/*_test.rb".size..-1]
+    assert_equal pattern, task.pattern[-pattern.size..-1]
+  end
+  
+  test "default pattern is test/**/*_test.rb" do
+    task = DeepTest::TestTask.new do |t|
+      t.stubs(:define)
     end
-    
-    test "default libs is ['lib']" do
-      task = TestTask.new do |t|
-        t.stubs(:define)
-      end
-      assert_equal ["lib"], task.libs
+    assert_equal "test/**/*_test.rb", task.pattern[-"test/**/*_test.rb".size..-1]
+  end
+  
+  test "default libs is ['lib']" do
+    task = DeepTest::TestTask.new do |t|
+      t.stubs(:define)
     end
+    assert_equal ["lib"], task.libs
+  end
 
-    test "can add to libs" do
-      task = TestTask.new do |t|
-        t.libs << "test"
-        t.stubs(:define)
-      end
-      assert_equal ["lib", "test"], task.libs
+  test "can add to libs" do
+    task = DeepTest::TestTask.new do |t|
+      t.libs << "test"
+      t.stubs(:define)
     end
-    
-    test "define passes the -I option to the call to ruby" do
-      task = TestTask.new do |t|
-        t.libs << "test"
-      end
-      task.expects(:ruby).with(includes("-Ilib:test"))
-      Rake::Task["deep_test"].instance_variable_get("@actions").last.call
+    assert_equal ["lib", "test"], task.libs
+  end
+  
+  test "define passes the -I option to the call to ruby" do
+    task = DeepTest::TestTask.new do |t|
+      t.libs << "test"
     end
+    task.expects(:ruby).with(includes("-Ilib:test"))
+    Rake::Task["deep_test"].instance_variable_get("@actions").last.call
+  end
 
-    test "define does not pass the -I option to the call to ruby if there are no directories to add to the load path" do
-      task = TestTask.new do |t|
-        t.libs = []
-      end
-      task.expects(:ruby).with(Not(includes("-I")))
-      Rake::Task["deep_test"].instance_variable_get("@actions").last.call
+  test "define does not pass the -I option to the call to ruby if there are no directories to add to the load path" do
+    task = DeepTest::TestTask.new do |t|
+      t.libs = []
     end
-    
-    test "number_of_agents defaults to count from CpuInfo" do
-      task = TestTask.new do |t|
-        t.stubs(:define)
-      end
-      CpuInfo.expects(:new).returns stub(:count => 2)
-      assert_equal 2, task.number_of_agents
+    task.expects(:ruby).with(Not(includes("-I")))
+    Rake::Task["deep_test"].instance_variable_get("@actions").last.call
+  end
+  
+  test "number_of_workers defaults to 2" do
+    task = DeepTest::TestTask.new do |t|
+      t.stubs(:define)
     end
-    
-    test "number_of_agents can be set" do
-      task = TestTask.new do |t|
-        t.number_of_agents = 42
-        t.stubs(:define)
-      end
-      assert_equal 42, task.number_of_agents
+    assert_equal 2, task.number_of_workers
+  end
+  
+  test "number_of_workers can be set" do
+    task = DeepTest::TestTask.new do |t|
+      t.number_of_workers = 42
+      t.stubs(:define)
     end
+    assert_equal 42, task.number_of_workers
   end
 end