jstorimer-deep-test 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+deep_test.metrics
+doc
+pkg
+tags
+negative_acceptance_tests/metrics.data
+

data/CHANGELOG

@@ -0,0 +1,47 @@
+1.2.2 (October 11, 2008)
+
+* Added libs option to DeepTest::TestTask for Rails 2.1 compatibility
+* RSpec 1.1.8  compatibility
+* Require RSpec 1.1.8
+
+1.2.1 (September 25, 2008)
+
+* rspec 1.1.4 compatibility
+* Requires rspec 1.1.4
+
+1.2.0 (March 28, 2008)
+
+* Added capability to run distributed
+* Changed to use straight DRb instead of Rinda (performance)
+* Changed error raised on before/after(:all) to warning
+* Added worker listener to setup mysql database for each worker
+* Run test server in same process
+* Check rspec version when loading rspec support
+* Add support for multiple worker listeners
+
+1.1.4 (March 11, 2008)
+
+* Fixed 2 RSpec pending example bugs
+* Fixed setting spec_opts with DeepTest bug
+* Raise an error if before or after all is defined
+* Added server_port to configuration options
+* Wait for signal from server indicating it is ready on startup
+
+1.1.3 (March 10, 2008)
+
+* Added Support for RSpec
+* Added DeepTest::TestTask#timeout_in_seconds to configure Rinda IO timeouts
+* Added worker_listener to configuration options
+
+1.1.2 (February 9, 2008)
+
+* Fix bug with run_test_suite script not exiting with correct exit code.
+
+1.1.1 (February 9, 2008)
+
+* No longer fork from Rake process.
+
+1.1.0 (December 23, 2007)
+
+* DeepTest::TestTask#processes= is now DeepTest::TestTask#number_of_workers=
+* No longer depend on the Daemons gem, use DeepTest::Warlock instead.

data/README.rdoc

@@ -0,0 +1,199 @@
+= DeepTest
+
+DeepTest enables tests to run in parallel using multiple processes.  Processes
+may spawned locally to take advantage of multiple processors on a single
+machine or distributed across many machines to take advantage of distributed
+processing.
+
+== Note
+
+This README has been updated to reflect changes made on the master branch that have
+not yet been released.  If you are looking for the README for DeepTest 1.2 it is
+availeble on the 1.2.x branch on github.
+
+== Usage
+
+In your Rakefile:
+
+  require "rubygems"
+  require "deep_test/rake_tasks"
+  
+  # sample DeepTest task
+
+  DeepTest::TestTask.new "task_name" do |t|
+    t.number_of_agents = 2   # optional, defaults to number of cores
+    t.pattern = "test/**/*_test.rb"
+    t.libs << "test" # may be necessary for Rails >= 2.1.x
+  end
+
+  # sample SpecTask using DeepTest
+
+  Spec::Rake::SpecTask.new(:deep_spec) do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.deep_test :number_of_agents => 2   # optional, defaults to number of cores
+  end
+
+
+=== Specifying a Listener to be Notified of Events
+
+In my_listener.rb
+  class MyListener
+    def before_sync
+    end
+
+    def before_starting_agents
+    end
+
+    def starting(agent)
+    end
+
+    def starting_work(agent, work_unit)
+    end
+
+    def finished_work(agent, work_unit, result)
+    end
+  end
+
+In your Rakefile
+
+  DeepTest::TestTask.new "task_name" do |t|
+    ... 
+    t.listener = "MyListener"
+  end
+
+An instance of MyListener will be created for each agent that is
+started, and will receive events from that agent.  However, you must ensure
+that the MyListener class is loaded at the time that the test files are
+loaded, so it is available to be instantiated.  You can specify multiple
+listener classes by separating them with a comma.  For more information about
+when events are triggered, see the documentation at
+DeepTest::NullListener.
+
+
+=== Setting Up A New Database For Each Agent
+
+By default, DeepTest will reinitialize ActiveRecord connections if ActiveRecord
+is loaded when the agents are started.  This means all agents are running
+against the same database.  You may want each agent to use a database
+decidicated to it.  To facilitate this, DeepTest provides a agent listener to
+help you.  If you're using Rails with Mysql, simply configure DeepTest as 
+follows in your Rakefile:
+
+  DeepTest::TestTask.new "task_name" do |t|
+    ...
+    t.listener = "DeepTest::Database::MysqlSetupListener"
+  end
+
+
+Before spawning agents, DeepTest will dump the schema of the database for the
+current Rails environment (usually test).  As each agent starts up, the
+listener will create a database dedicated to that agent and load the schema
+into it.  The database will be dropped when the agent process exits.  
+
+If you're using Mysql but not using Rails, you'll have to create a subclass of
+MysqlSetupListener and override +master_database_config+ and +dump_file_name+,
+as the default implementations of these methods are Rails specific.
+
+
+If you're using a database other than Mysql, read the documentation for
+DeepTest::Database::SetupListener and create a new subclass for your database
+type.  If you do this, please consider contributing your subclass back to the
+project so that it can be included in later releases of DeepTest.
+
+=== Distributing Tests Across Multiple Machines
+
+In addition to running your tests in parallel, DeepTest can also distribute
+them across multiple machines.  It does this by first mirroring the local
+working copy that launched the tests on each machine that will be running tests.
+Then agents are launched on each of the machines and consume tests in the same
+fashion as when DeepTest is running locally.
+
+==== Requirements
+
+Before you can distribute tests, you must ensure that all the machines involved
+(including the machine with the local working copy) have rsync installed for
+mirroring working copies.  You must also have either SSH or an RSync daemon
+exposing your local working copy running on the local development machine.  For
+more information about rsync, visit the rsync
+webpage[http://www.samba.org/rsync/].  Currently only passwordless access is
+supported, so you must either setup your RSync daemon to be accessible without
+a password or enable passwordless SSH access from the test machines to the
+local development machine. DeepTest must also be installed as a gem on each
+test machine and available either as a gem or in your project on the local
+machine.
+
+==== Configuring Your Project
+
+There is no need to start a special daemon process on the machines that will
+be used to run DeepTest.  Simply specify the names of the hosts that you
+would like DeepTest to distribute to along with a set of sync_options telling
+it how to to rsync the project code.
+
+If you're using rsync over ssh, create a DeepTest test task similar to that
+below in your Rakefile.
+
+  DeepTest::TestTask.new "deep_test_distributed" do |t|
+    t.pattern = "test/**/*_test.rb" # whatever is appropriate for your project
+    t.distributed_hosts = %w[host1 host2]
+    t.sync_options = {
+      :source => <absolute path of project root on machine>,
+      :username => "username",
+      :remote_base_dir => <absolute path to keep working copies in on remote machine> # defaults to /tmp
+    }
+  end
+
+The :source entry in sync_options can be easily calculated based on the value
+of \_\_FILE__ when defining the task.  :username will be used by rsync to ssh
+back to the local machine and mirror the working copy.
+
+If you have an rsync daemon running in your local machine, configure the
+rake task as follows.
+
+  DeepTest::TestTask.new "deep_test_distributed" do |t|
+    t.pattern = "test/**/*_test.rb" # whatever is appropriate for your project
+    t.distributed_hosts = %w[host1 host2]
+    t.sync_options = {
+      :source => <name of rsync module from daemon configuration>,
+      :daemon => true,
+      :username => "username"
+    }
+  end
+
+Username is optional in both cases.  You'll need to either setup passwordless
+ssh access or run an rsync daemon that doesn't require passwords.
+
+There may be other options you'd like to pass to rsync in your particular
+scenario.  This can be done by adding an :rsync_options entry to sync_options.
+For example, if you're working on a Rails project you'll probably want to at
+least have something like this:
+
+  DeepTest::TestTask.new "deep_test_distributed" do |t|
+    ...
+    excludes = %w[.svn tmp/** log/**]
+    t.sync_options = {
+      ...
+      :rsync_options => excludes.map {|s| "'--exclude=#{s}'"}.join(' ')
+    }
+  end
+
+That way you can avoid spending any time mirroring tmp and log files that don't
+have any effect on the tests.  If you are running distributed tests against a
+database, consult the section above about creating a new database for each
+agent to see how to configure DeepTest for your project.  
+
+Any number of projects can be run using the same test servers, as long as
+they're all using the same version of Ruby and DeepTest.  
+
+== Contributors
+
+* anonymous z
+* Alex Chaffee
+* Dan[http://www.dcmanges.com/blog] Manges[http://www.dcmanges.com/blog]
+* David[http://davidvollbracht.com/] Vollbracht[http://davidvollbracht.com/]
+* Brian[http://blog.brianguthrie.com/] Guthrie[http://blog.brianguthrie.com/]
+* Shane[http://shanel.tumblr.com/] Liebling[http://shanel.tumblr.com/]
+* Scott Taylor
+
+== License
+
+DeepTest Released under Ruby's[http://www.ruby-lang.org/en/LICENSE.txt] license[http://www.ruby-lang.org/en/LICENSE.txt]

data/Rakefile

@@ -0,0 +1,150 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+require 'yaml'
+
+require 'rubygems'
+gem('rspec', ENV['RSPEC_VERSION'] || '1.1.12')
+require 'spec/rake/spectask'
+
+$LOAD_PATH << File.dirname(__FILE__) + "/lib"
+
+require "deep_test/rake_tasks"
+
+task :default => %w[
+  test 
+  spec 
+  deep_test
+  deep_spec_1.1.8
+  deep_spec_1.1.12
+  distributed_test
+  distributed_spec
+  negative_acceptance_tests
+  test_rails_project
+]
+
+task :pc => :default
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.libs += ['test', 'lib']
+end
+
+DeepTest::TestTask.new :deep_test do |t|
+  t.pattern = "test/**/*_test.rb"
+end
+
+DeepTest::TestTask.new(:manual_distributed_test) do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.distributed_hosts = (ENV['HOSTS'] || '').split(' ')
+  t.sync_options = {:source => File.dirname(__FILE__), 
+                    :username => ENV['USERNAME'],
+                    :rsync_options => "--exclude=.svn"}
+end
+
+DeepTest::TestTask.new(:distributed_test) do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.distributed_hosts = %w[localhost]
+  t.sync_options = {:source => File.dirname(__FILE__), 
+                    :rsync_options => "--exclude=.svn",
+                    :remote_base_dir => "/tmp/deep_test"}
+end
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:deep_spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.deep_test({})
+end
+
+task :'deep_spec_1.1.8' do 
+  sh 'rake deep_spec RSPEC_VERSION=1.1.8'
+end
+
+task :'deep_spec_1.1.12' do
+  sh 'rake deep_spec RSPEC_VERSION=1.1.12'
+end
+
+Spec::Rake::SpecTask.new(:distributed_spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.deep_test :distributed_hosts => %w[localhost],
+              :sync_options => {:source => File.dirname(__FILE__), 
+                                :rsync_options => "--exclude=.svn"}
+end
+
+Rake::TestTask.new(:negative_acceptance_tests) do |t|
+  t.pattern = "negative_acceptance_tests/tests.rb"
+end
+
+Rake::TestTask.new(:test_rails_project) do |t|
+  t.pattern = "sample_rails_project/deep_test.rb"
+end
+
+desc "Generate documentation"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "doc"
+  rdoc.title    = "DeepTest"
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include(
+    'README.rdoc', 
+    'CHANGELOG', 
+    'lib/deep_test/null_listener.rb',
+    'lib/deep_test/database/*.rb'
+  )
+end
+
+desc "Upload RDoc to RubyForge"
+task :publish_rdoc => [:rerdoc] do
+  rubyforge_config = "#{ENV['HOME']}/.rubyforge/user-config.yml"
+  username = YAML.load_file(rubyforge_config)["username"]
+  sh "chmod -R 775 doc"
+  sh "scp -rqp doc/* #{username}@rubyforge.org:/var/www/gforge-projects/deep-test"
+end
+
+specification = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+	s.name   = "deep_test"
+  s.summary = "DeepTest runs tests in multiple processes."
+	s.version = "1.2.2"
+	s.author = "anonymous z, Dan Manges, David Vollbracht"
+	s.description = s.summary
+	s.email = "daniel.manges@gmail.com"
+  s.homepage = "http://deep-test.rubyforge.org"
+  s.rubyforge_project = "deep-test"
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.rdoc', 'CHANGELOG']
+  s.rdoc_options << '--title' << "DeepTest" << '--main' << 'README.rdoc' << '--line-numbers'
+
+  s.files = FileList['{lib,test}/**/*.{rb,rake}', 'README.rdoc', 'CHANGELOG', 'Rakefile'].to_a
+end
+
+Rake::GemPackageTask.new(specification) do |package|
+  package.need_zip = true
+  package.need_tar = true
+end
+
+Rake::Task[:gem].prerequisites.unshift :default
+
+task :tar do
+  system "tar zcf pkg/deep_test.tar.gz --exclude=.svn --exclude='*.tar.gz' --exclude='*.gem' --directory=.. deep_test"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "jstorimer-deep-test"
+    gemspec.summary = "Edge version of deep-test"
+    gemspec.description = "Parallelized testing"
+    gemspec.email = "jstorimer@gmail.com"
+    gemspec.homepage = "http://github.com/qxjit/deep-test/"
+    gemspec.authors = ["Josh Nichols"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/TODO

@@ -0,0 +1,4 @@
+* Graceful handling if agents fail to start.
+* test loader
+* Log central_command write error
+* Handle not getting all results make more gracefully

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/infrastructure/dynamic_teardown.rb

@@ -0,0 +1,22 @@
+module DynamicTeardown
+  class <<self
+    def setup
+      stack.push []
+    end
+
+    def stack
+      @stack ||= []
+    end
+
+    def on_teardown(&block)
+      stack.last << block
+    end
+
+    def teardown
+      teardowns = stack.pop
+      while td = teardowns.shift
+        td.call rescue nil
+      end
+    end
+  end
+end

data/infrastructure/fake_deadlock_error.rb

@@ -0,0 +1,12 @@
+unless defined?(ActiveRecord::StatementInvalid)
+  module ActiveRecord
+    class StatementInvalid < StandardError
+    end
+  end
+end
+
+class FakeDeadlockError
+  def self.new
+    ActiveRecord::StatementInvalid.new("Deadlock found when trying to get lock")
+  end
+end

data/infrastructure/load.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/timewarp/lib/timewarp"
+require File.dirname(__FILE__) + "/fake_deadlock_error"
+require File.dirname(__FILE__) + "/test_central_command"
+require File.dirname(__FILE__) + "/test_factory"
+require File.dirname(__FILE__) + "/test_logger"
+require File.dirname(__FILE__) + "/test_exception"
+require File.dirname(__FILE__) + "/test_result"
+require File.dirname(__FILE__) + "/test_operator"
+require File.dirname(__FILE__) + "/dynamic_teardown"
+require File.dirname(__FILE__) + "/thread_agent"
+

data/infrastructure/test_central_command.rb

@@ -0,0 +1,15 @@
+module DeepTest
+  class TestCentralCommand < CentralCommand
+    def self.start(options)
+      central_command = super
+      DynamicTeardown.on_teardown { central_command.stop }
+      central_command
+    end
+
+    def remaining_result_count
+      @results_mutex.synchronize do
+        @results.size
+      end
+    end
+  end
+end

data/infrastructure/test_exception.rb

@@ -0,0 +1,7 @@
+module DeepTest
+  class TestException < StandardError
+    def ==(other)
+      other.class == self.class && other.message == message
+    end
+  end
+end

data/infrastructure/test_factory.rb

@@ -0,0 +1,74 @@
+module TestFactory
+  def self.failing_test
+    test_class do
+      def test_failing
+        assert_equal 1, 0
+      end
+    end.new(:test_failing)
+  end
+
+  def self.passed_result
+    result = Test::Unit::TestResult.new
+    result.add_run
+    result.add_assertion
+    result
+  end
+
+  def self.passing_test
+    test_class do
+      def test_passing
+        assert_equal 0, 0
+      end
+    end.new(:test_passing)
+  end
+  
+  def self.passing_test_with_stdout
+    test_class do
+      def test_passing_with_stdout
+        print "message printed to stdout"
+        assert true
+      end
+    end.new :test_passing_with_stdout
+  end
+  
+  def self.deadlock_once_test
+    test_class do
+      def test_deadlock_once
+        if @deadlocked
+          assert true
+        else
+          @deadlocked = true
+          raise FakeDeadlockError.new
+        end
+      end
+    end.new :test_deadlock_once
+  end
+  
+  def self.deadlock_always_test
+    test_class do
+      def test_deadlock_always
+        raise FakeDeadlockError.new
+      end
+    end.new :test_deadlock_always
+  end
+
+  def self.suite
+    Test::Unit::TestSuite.new
+  end
+
+  def self.test_class(&block)
+    test_class = Class.new(Test::Unit::TestCase)
+
+    class_name = external_caller.upcase.gsub(/[^A-Z0-9]/,"_").sub(/^_*/,'')
+    const_set(class_name, test_class)
+
+    test_class.class_eval &block
+    test_class
+  end
+
+  def self.external_caller
+    caller.each do |trace_line|
+      return trace_line unless trace_line =~ /test_factory.rb/
+    end
+  end
+end

data/infrastructure/test_logger.rb

@@ -0,0 +1,11 @@
+class TestLogger < DeepTest::Logger
+  def initialize(device = nil)
+    super(StringIO.new)
+  end
+
+  def logged_output
+    io_stream.string
+  end
+end
+
+

data/infrastructure/test_operator.rb

@@ -0,0 +1,15 @@
+module DeepTest
+  class TestOperator < Telegraph::Operator
+    def self.listen(options = nil)
+      operator = super("localhost", 0, Telegraph::Switchboard.new)
+      DynamicTeardown.on_teardown { operator = shutdown }
+      options.server_port = operator.port if options
+      operator 
+    end
+
+    def next_message
+      @switchboard.next_message(:timeout => 0.1)
+    end
+  end
+end
+

data/infrastructure/test_result.rb

@@ -0,0 +1,15 @@
+module DeepTest
+  class TestResult
+    include CentralCommand::Result
+    attr_reader :value
+
+    def initialize(value)
+      @value == value
+    end
+
+    def ==(other)
+      value == other.value
+    end
+  end
+end
+

data/infrastructure/thread_agent.rb

@@ -0,0 +1,21 @@
+module DeepTest
+  class ThreadAgent < Agent
+    attr_reader :work_done
+
+    def initialize(options)
+      super(0, options, ListenerList.new([]))
+      @thread = Thread.new { execute(StringIO.new, StringIO.new) }
+      @work_done = 0
+    end
+
+    def wait_until_done
+      Timeout.timeout(5) {@thread.join}
+      @thread.kill if @thread.alive?
+    end
+
+    def send_result(*args)
+      super
+      @work_done += 1
+    end
+  end
+end

data/infrastructure/timewarp/Rakefile

@@ -0,0 +1,14 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => %w[
+  test 
+]
+
+task :pc => :default
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.libs += ['test', 'lib']
+end
+

data/infrastructure/timewarp/lib/timewarp.rb

@@ -0,0 +1,21 @@
+require 'time'
+
+module Timewarp
+  def self.freeze(time, &block)
+    frozen_time = time.is_a?(String) ? Time.parse(time) : time
+    control_timeline proc {frozen_time}, &block
+  end
+
+  def self.control_timeline(timeline_proc)
+    (class <<Time; self; end).class_eval do
+      alias original_now now
+      define_method(:now) { timeline_proc.call }
+    end
+    yield
+  ensure
+    (class <<Time; self; end).class_eval do
+      alias now original_now
+      remove_method :original_now
+    end
+  end
+end