jstorimer-deep-test 1.4.0 → 2.0.0

data/test/deep_test/distributed/throughput_worker_client_test.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-unit_tests do
-  test "start_all starts workers on a new worker server" do
-    client = DeepTest::Distributed::ThroughputWorkerClient.new(
-      options = DeepTest::Options.new({}),
-      test_server = stub_everything
-    )
-
-    test_server.expects(:spawn_worker_server).with(options).
-      returns(worker_server = stub_everything)
-
-    worker_server.expects(:start_all)
-    client.start_all
-  end
-
-  test "stop_all stops workers on worker server that was spawned in start_all" do
-    worker_server = stub_everything
-    client = DeepTest::Distributed::ThroughputWorkerClient.new(
-      DeepTest::Options.new({}),
-      test_server = stub_everything(:spawn_worker_server => worker_server)
-    )
-
-    client.start_all
-    worker_server.expects(:stop_all)
-    client.stop_all
-  end
-end

data/test/deep_test/local_workers_test.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-
-unit_tests do
-  test "number_of_workers is determined by options" do
-    workers = DeepTest::LocalWorkers.new(
-      DeepTest::Options.new(:number_of_workers => 4)
-    )
-
-    assert_equal 4, workers.number_of_workers
-  end
-
-  test "load_files simply loads each file provided" do
-    workers = DeepTest::LocalWorkers.new(
-      DeepTest::Options.new(:number_of_workers => 4)
-    )
-
-    workers.expects(:load).with(:file_1)
-    workers.expects(:load).with(:file_2)
-
-    workers.load_files([:file_1, :file_2])
-  end
-end

data/test/deep_test/metrics/gatherer_test.rb

@@ -1,66 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-unit_tests do
-  test "section uses block to add measurements when render is called" do
-    i = j = 0
-    section = DeepTest::Metrics::Gatherer::Section.new("my section") do |s|
-      s.measurement("i", i)
-      s.measurement("j", j)
-    end
-
-    i = 1
-    j = 2
-
-    rendered_string = section.render
-
-    assert_match /^i: 1$/, rendered_string
-    assert_match /^j: 2$/, rendered_string
-  end
-
-  test "section starts with title" do
-    section = DeepTest::Metrics::Gatherer::Section.new("my section") {|s|}
-    assert_equal "[my section]\n", section.render
-  end
-
-  test "gatherer renders all sections defined" do
-    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new(:metrics_file => "something"))
-    gatherer.section("section 1") {|s|}
-    gatherer.section("section 2") {|s|}
-
-    assert_equal "[section 1]\n\n[section 2]\n", gatherer.render
-  end
-
-  test "no sections are added if not gathering metrics" do
-    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new({}))
-    gatherer.section("section 1") {|s|}
-    gatherer.section("section 2") {|s|}
-
-    assert_equal "", gatherer.render
-  end
-
-  test "enabled? is true if metrics_file is specified" do
-    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new(:metrics_file => "something"))
-    assert_equal true, gatherer.enabled?
-  end
-
-  test "enabled? is false if metrics_file is not specified" do
-    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new({}))
-    assert_equal false, gatherer.enabled?
-  end
-
-  test "write_file writes rendered contents to metrics file" do
-    gatherer = DeepTest::Metrics::Gatherer.new(
-      DeepTest::Options.new(:metrics_file => "a_file")
-    )
-    gatherer.section("section 1") {|s|}
-    File.expects(:open).with("a_file", "w").yields(io = StringIO.new)
-    gatherer.write_file
-    assert_equal gatherer.render, io.string
-  end
-
-  test "write_file does nothing if not enabled" do
-    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new({}))
-    File.expects(:open).never
-    gatherer.write_file
-  end
-end

data/test/deep_test/process_orchestrator_test.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-
-unit_tests do
-  test "shutdown calls done_with_work" do
-    orchestrator = DeepTest::ProcessOrchestrator.new(nil, stub_everything, nil)
-    server = mock
-    server.expects(:done_with_work)
-
-    orchestrator.shutdown(server)
-  end
-end

data/test/deep_test/server_test.rb

@@ -1,58 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-
-unit_tests do
-  test "take_work returns result of push_work when it is available" do
-    server = DeepTest::Server.new(DeepTest::Options.new({}))
-    server.write_work :work
-    assert_equal :work, server.take_work
-  end
-
-  test "take_work raises error when no work is currently available" do
-    assert_raises(DeepTest::Server::NoWorkUnitsAvailableError) do
-      DeepTest::Server.new(DeepTest::Options.new({})).take_work
-    end
-  end
-
-  test "take_work raises error when there is no work left to" do
-    server = DeepTest::Server.new(DeepTest::Options.new({}))
-    server.done_with_work
-
-    assert_raises(DeepTest::Server::NoWorkUnitsRemainingError) do
-      server.take_work
-    end
-  end
-
-  test "take_result returns result of push_result when it is available" do
-    server = DeepTest::Server.new(DeepTest::Options.new({}))
-    t = Thread.new {server.take_result}
-    server.write_result :result
-    assert_equal :result, t.value
-  end
-
-  test "take_result timeouts out after configurable number of seconds" do
-    server = DeepTest::Server.new(
-      DeepTest::Options.new(:timeout_in_seconds => 0.01)
-    )
-    Thread.new {sleep 0.1; server.write_result :too_late}
-    assert_raises(DeepTest::Server::ResultOverdueError) {server.take_result}
-  end
-
-  test "write_work returns nil" do
-    server = DeepTest::Server.new(DeepTest::Options.new({}))
-    assert_equal nil, server.write_work(:a)
-  end
-
-  test "write_result returns nil" do
-    server = DeepTest::Server.new(DeepTest::Options.new({}))
-    assert_equal nil, server.write_result(:a)
-  end
-
-  test "start returns instance of server" do
-    DRb.expects(:start_service)
-    DRb.expects(:uri)
-    DeepTest.logger.expects(:info)
-
-    server = DeepTest::Server.start(DeepTest::Options.new({}))
-    assert_kind_of DeepTest::Server, server
-  end
-end

data/test/deep_test/worker_test.rb

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

@@ -1,11 +0,0 @@
-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/test/simple_test_blackboard.rb

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

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