jstorimer-deep-test 1.4.0 → 2.0.0

data/.gitignore

@@ -2,4 +2,5 @@ deep_test.metrics
 doc
 pkg
 tags
+negative_acceptance_tests/metrics.data
 

data/README.rdoc

@@ -5,6 +5,12 @@ 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:
@@ -15,9 +21,7 @@ In your Rakefile:
   # sample DeepTest task
 
   DeepTest::TestTask.new "task_name" do |t|
-    t.number_of_workers = 2   # optional, defaults to 2
-    t.timeout_in_seconds = 30 # optional, defaults to 30
-    t.server_port = 6969      # optional, defaults to 6969
+    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
@@ -26,29 +30,27 @@ In your Rakefile:
 
   Spec::Rake::SpecTask.new(:deep_spec) do |t|
     t.spec_files = FileList['spec/**/*_spec.rb']
-    t.deep_test :number_of_workers => 2,   # optional, defaults to 2
-                :timeout_in_seconds => 30, # optional, defaults to 30
-                :server_port => 6969       # optional, defaults to 6969
+    t.deep_test :number_of_agents => 2   # optional, defaults to number of cores
   end
 
 
 === Specifying a Listener to be Notified of Events
 
-In my_worker_listener.rb
-  class MyWorkerListener
+In my_listener.rb
+  class MyListener
     def before_sync
     end
 
-    def before_starting_workers
+    def before_starting_agents
     end
 
-    def starting(worker)
+    def starting(agent)
     end
 
-    def starting_work(worker, work_unit)
+    def starting_work(agent, work_unit)
     end
 
-    def finished_work(worker, work_unit, result)
+    def finished_work(agent, work_unit, result)
     end
   end
 
@@ -56,37 +58,37 @@ In your Rakefile
 
   DeepTest::TestTask.new "task_name" do |t|
     ... 
-    t.worker_listener = "MyWorkerListener"
+    t.listener = "MyListener"
   end
 
-An instance of MyWorkerListener will be created for each worker that is
-started, and will receive events from that worker.  However, you must ensure
-that the MyWorkerListener class is loaded at the time that the test files are
+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::NullWorkerListener.
+DeepTest::NullListener.
 
 
-=== Setting Up A New Database For Each Worker
+=== Setting Up A New Database For Each Agent
 
 By default, DeepTest will reinitialize ActiveRecord connections if ActiveRecord
-is loaded when the workers are started.  This means all workers are running
-against the same database.  You may want each worker to use a database
-decidicated to it.  To facilitate this, DeepTest provides a worker listener to
+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.worker_listener = "DeepTest::Database::MysqlSetupListener"
+    t.listener = "DeepTest::Database::MysqlSetupListener"
   end
 
 
-Before spawning workers, DeepTest will dump the schema of the database for the
-current Rails environment (usually test).  As each worker starts up, the
-listener will create a database dedicated to that worker and load the schema
-into it.  The database will be dropped when the worker process exits.  
+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+,
@@ -103,7 +105,7 @@ project so that it can be included in later releases of DeepTest.
 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 workers are launched on each of the machines and consume tests in the same
+Then agents are launched on each of the machines and consume tests in the same
 fashion as when DeepTest is running locally.
 
 ==== Requirements
@@ -120,55 +122,23 @@ 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.
 
-==== Starting a Test Server
-
-On each test machine, execute the following:
-  > deep_test test_server
-
-This will launch a server providing mirroring and worker services.  By default,
-2 workers will be launched for each set of tests run.  If you wish to change
-the number of workers, simply specify the --number_of_workers option.  For
-information about what options are available, use -h.  The test_server will
-print out the uri it is bound to, druby://<hostname>:4022 by default.
-
-==== Starting a Master Test Server
-
-On a single machine (probably one of the test machines), execute this:
-  > deep_test master_test_server <uris of test servers>
-
-The master_test_server will also print it's binding uri,
-druby://<hostname>:4021 by default.  It will also provide a webserver bound
-to port 4020 that provides a status page summarizing the state of all the
-test servers. 
-
-==== Overriding the DRb uri for the Test Server or Master Test Server
-
-The DRb url that the Test Server or Master Test Server should bind to can be
-specified when the process is started.  Use the --uri option followed by the
-DRb url that you would like DRb to bind to and return to clients.  By default,
-DRb does not provide any capability to bind to all addresses but return a
-specific IP or hostname as part of the DRb url for clients.  DeepTest provides
-a special DRb protocol to enable this, drubyall.  If you wish your test server
-to listen on all addresses (which you probably do), start the server
-with a command like this (where deeptest1.local is the hostname of the machine):
-  > deep_test test_server --uri drubyall://deeptest1.local/
-
-The server will report that it is listening on druby://deeptest1.local as the
-public DRb url, but it will actually accept connections on all addresses to
-server requests.
- 
-
 ==== 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_server = <drb uri of master_test_server>
+    t.distributed_hosts = %w[host1 host2]
     t.sync_options = {
       :source => <absolute path of project root on machine>,
-      :username => "username"
+      :username => "username",
+      :remote_base_dir => <absolute path to keep working copies in on remote machine> # defaults to /tmp
     }
   end
 
@@ -181,7 +151,7 @@ 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_server = <drb uri of master_test_server>
+    t.distributed_hosts = %w[host1 host2]
     t.sync_options = {
       :source => <name of rsync module from daemon configuration>,
       :daemon => true,
@@ -189,7 +159,6 @@ rake task as follows.
     }
   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.
 
@@ -210,7 +179,7 @@ least have something like this:
 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
-worker to see how to configure DeepTest for your project.  
+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.  
@@ -221,6 +190,8 @@ they're all using the same version of Ruby and DeepTest.
 * 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

data/Rakefile

@@ -6,21 +6,22 @@ require 'rake/contrib/sshpublisher'
 require 'yaml'
 
 require 'rubygems'
-gem 'rspec', '=1.1.8'
+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 
-  failing_test
   deep_test
-  deep_spec
-  run_distributed
-  run_distributed_with_worker_down
-  run_distributed_with_failover
+  deep_spec_1.1.8
+  deep_spec_1.1.12
+  distributed_test
+  distributed_spec
+  negative_acceptance_tests
   test_rails_project
 ]
 
@@ -32,123 +33,51 @@ Rake::TestTask.new do |t|
 end
 
 DeepTest::TestTask.new :deep_test do |t|
-  t.number_of_workers = 2
   t.pattern = "test/**/*_test.rb"
-  t.metrics_file = "deep_test.metrics"
 end
 
-DeepTest::TestTask.new(:distributed_test) do |t|
-  t.number_of_workers = 2
+DeepTest::TestTask.new(:manual_distributed_test) do |t|
   t.pattern = "test/**/*_test.rb"
-  t.distributed_server = "druby://localhost:8000"
+  t.distributed_hosts = (ENV['HOSTS'] || '').split(' ')
   t.sync_options = {:source => File.dirname(__FILE__), 
-                    :local => true,
+                    :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 :number_of_workers => 2
+  t.deep_test({})
 end
 
-Spec::Rake::SpecTask.new(:distributed_spec) do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
-  t.deep_test :number_of_workers => 2, 
-              :distributed_server => "druby://localhost:8000",
-              :sync_options => {:source => File.dirname(__FILE__), 
-                                :local => true,
-                                :rsync_options => "--exclude=.svn"}
+task :'deep_spec_1.1.8' do 
+  sh 'rake deep_spec RSPEC_VERSION=1.1.8'
 end
 
-DeepTest::TestTask.new(:distribute_tests_to_minis) do |t|
-  t.number_of_workers = 2
-  t.pattern = "test/**/*_test.rb"
-  t.distributed_server = "druby://alpha.local:8000"
-  t.sync_options = {:source => File.dirname(__FILE__), 
-                    :username => "tworker",
-                    :password => "thought",
-                    :rsync_options => "--exclude=.svn"}
+task :'deep_spec_1.1.12' do
+  sh 'rake deep_spec RSPEC_VERSION=1.1.12'
 end
 
-task :run_distributed do |t|
-  begin
-    FileUtils.mkdir('/tmp/test_1') unless File.exist?('/tmp/test_1')
-    FileUtils.mkdir('/tmp/test_2') unless File.exist?('/tmp/test_2')
-
-    test_1_pid = fork do
-      exec "ruby bin/deep_test test_server --uri drubyall://localhost:8001 --work_dir /tmp/test_1"
-    end
-
-    test_2_pid = fork do
-      exec "ruby bin/deep_test test_server --uri drubyall://localhost:8002 --work_dir /tmp/test_2"
-    end
-
-    master_pid = fork do
-      exec "ruby bin/deep_test master_test_server --uri drubyall://localhost:8000 druby://localhost:8001 druby://localhost:8002"
-    end
-
-    sleep 1
-
-    Rake::Task[:distributed_test].invoke
-    Rake::Task[:distributed_spec].invoke
-
-    sh "ruby bin/deep_test test_throughput druby://localhost:8000 20"
-  ensure
-    Process.kill('TERM', master_pid) if master_pid rescue nil
-    Process.kill('TERM', test_1_pid) if test_1_pid rescue nil
-    Process.kill('TERM', test_2_pid) if test_2_pid rescue nil
-    Process.waitall
-  end
-
-  sleep 1
-end
-
-task :run_distributed_with_worker_down do |t|
-  begin
-    FileUtils.mkdir('/tmp/test_1') unless File.exist?('/tmp/test_1')
-
-    test_1_pid = fork do
-      exec "ruby bin/deep_test test_server --uri drubyall://localhost:8001 --work_dir /tmp/test_1"
-    end
-
-    # don't start worker 2
-
-    master_pid = fork do
-      exec "ruby bin/deep_test master_test_server --uri drubyall://localhost:8000 druby://localhost:8001 druby://localhost:8002"
-    end
-
-    sleep 1
-
-    # Use throughput to make sure we can run tests
-    sh "ruby bin/deep_test test_throughput druby://localhost:8000 20"
-  ensure
-    Process.kill('TERM', master_pid) if master_pid rescue nil
-    Process.kill('TERM', test_1_pid) if test_1_pid rescue nil
-    Process.waitall
-  end
-end
-
-task :run_distributed_with_failover do |t|
-  puts
-  puts "*** Running distributed with no server - expect a failover message ***"
-  puts
-  Rake::Task[:distributed_spec].execute "dummy arg"
+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
 
-task :failing_test do
-  command = "rake --rakefile test/failing.rake 2>&1"
-  puts command
-  `#{command}`
-  if $?.success?
-    puts "F"
-    fail "****\ntest/failing.rake should have failed\n****"
-  else
-    puts "."
-  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|
@@ -163,7 +92,7 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include(
     'README.rdoc', 
     'CHANGELOG', 
-    'lib/deep_test/null_worker_listener.rb',
+    'lib/deep_test/null_listener.rb',
     'lib/deep_test/database/*.rb'
   )
 end
@@ -186,13 +115,27 @@ specification = Gem::Specification.new do |s|
 	s.email = "daniel.manges@gmail.com"
   s.homepage = "http://deep-test.rubyforge.org"
   s.rubyforge_project = "deep-test"
-  s.executables << "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,script,test,bin}/**/*.{rb,rake,rhtml}', 'README.rdoc', 'CHANGELOG', 'Rakefile'].to_a
+  s.files = FileList['{lib,test}/**/*.{rb,rake}', 'README.rdoc', 'CHANGELOG', 'Rakefile'].to_a
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+  	gemspec.name   = "jstorimer-deep-test"
+    gemspec.summary = "DeepTest runs tests in multiple processes."
+  	gemspec.author = "anonymous z, Dan Manges, David Vollbracht"
+  	gemspec.description = gemspec.summary
+  	gemspec.email = "daniel.manges@gmail.com"
+    gemspec.homepage = "http://deep-test.rubyforge.org"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
 end
 
 Rake::GemPackageTask.new(specification) do |package|
@@ -205,18 +148,3 @@ 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