jstorimer-deep-test 0.2.0 → 1.0.0

data/.gitignore

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

data/README.rdoc

@@ -5,12 +5,6 @@ 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:
@@ -21,7 +15,9 @@ In your Rakefile:
   # sample DeepTest task
 
   DeepTest::TestTask.new "task_name" do |t|
-    t.number_of_agents = 2   # optional, defaults to number of cores
+    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.pattern = "test/**/*_test.rb"
     t.libs << "test" # may be necessary for Rails >= 2.1.x
   end
@@ -30,27 +26,29 @@ In your Rakefile:
 
   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
+    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
   end
 
 
 === Specifying a Listener to be Notified of Events
 
-In my_listener.rb
-  class MyListener
+In my_worker_listener.rb
+  class MyWorkerListener
     def before_sync
     end
 
-    def before_starting_agents
+    def before_starting_workers
     end
 
-    def starting(agent)
+    def starting(worker)
     end
 
-    def starting_work(agent, work_unit)
+    def starting_work(worker, work_unit)
     end
 
-    def finished_work(agent, work_unit, result)
+    def finished_work(worker, work_unit, result)
     end
   end
 
@@ -58,37 +56,37 @@ In your Rakefile
 
   DeepTest::TestTask.new "task_name" do |t|
     ... 
-    t.listener = "MyListener"
+    t.worker_listener = "MyWorkerListener"
   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
+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
 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.
+DeepTest::NullWorkerListener.
 
 
-=== Setting Up A New Database For Each Agent
+=== Setting Up A New Database For Each Worker
 
 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
+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
 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"
+    t.worker_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.  
+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.  
 
 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+,
@@ -105,7 +103,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 agents are launched on each of the machines and consume tests in the same
+Then workers are launched on each of the machines and consume tests in the same
 fashion as when DeepTest is running locally.
 
 ==== Requirements
@@ -122,23 +120,55 @@ 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
+==== 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>
 
-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.
+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
 
 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.distributed_server = <drb uri of master_test_server>
     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
+      :username => "username"
     }
   end
 
@@ -151,7 +181,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_hosts = %w[host1 host2]
+    t.distributed_server = <drb uri of master_test_server>
     t.sync_options = {
       :source => <name of rsync module from daemon configuration>,
       :daemon => true,
@@ -159,6 +189,7 @@ 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.
 
@@ -179,7 +210,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
-agent to see how to configure DeepTest for your project.  
+worker 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.  
@@ -190,8 +221,6 @@ 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,22 +6,21 @@ require 'rake/contrib/sshpublisher'
 require 'yaml'
 
 require 'rubygems'
-gem('rspec', ENV['RSPEC_VERSION'] || '1.1.12')
+gem 'rspec', '=1.1.8'
 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_1.1.8
-  deep_spec_1.1.12
-  distributed_test
-  distributed_spec
-  negative_acceptance_tests
+  deep_spec
+  run_distributed
+  run_distributed_with_worker_down
+  run_distributed_with_failover
   test_rails_project
 ]
 
@@ -33,23 +32,18 @@ Rake::TestTask.new do |t|
 end
 
 DeepTest::TestTask.new :deep_test do |t|
+  t.number_of_workers = 2
   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"}
+  t.metrics_file = "deep_test.metrics"
 end
 
 DeepTest::TestTask.new(:distributed_test) do |t|
+  t.number_of_workers = 2
   t.pattern = "test/**/*_test.rb"
-  t.distributed_hosts = %w[localhost]
+  t.distributed_server = "druby://localhost:8000"
   t.sync_options = {:source => File.dirname(__FILE__), 
-                    :rsync_options => "--exclude=.svn",
-                    :remote_base_dir => "/tmp/deep_test"}
+                    :local => true,
+                    :rsync_options => "--exclude=.svn"}
 end
 
 Spec::Rake::SpecTask.new(:spec) do |t|
@@ -58,26 +52,103 @@ 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'
+  t.deep_test :number_of_workers => 2
 end
 
 Spec::Rake::SpecTask.new(:distributed_spec) do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
-  t.deep_test :distributed_hosts => %w[localhost],
+  t.deep_test :number_of_workers => 2, 
+              :distributed_server => "druby://localhost:8000",
               :sync_options => {:source => File.dirname(__FILE__), 
+                                :local => true,
                                 :rsync_options => "--exclude=.svn"}
 end
 
-Rake::TestTask.new(:negative_acceptance_tests) do |t|
-  t.pattern = "negative_acceptance_tests/tests.rb"
+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"}
+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"
+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
 end
 
 Rake::TestTask.new(:test_rails_project) do |t|
@@ -92,7 +163,7 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include(
     'README.rdoc', 
     'CHANGELOG', 
-    'lib/deep_test/null_listener.rb',
+    'lib/deep_test/null_worker_listener.rb',
     'lib/deep_test/database/*.rb'
   )
 end
@@ -115,12 +186,13 @@ 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,test}/**/*.{rb,rake}', 'README.rdoc', 'CHANGELOG', 'Rakefile'].to_a
+  s.files = FileList['{lib,script,test,bin}/**/*.{rb,rake,rhtml}', 'README.rdoc', 'CHANGELOG', 'Rakefile'].to_a
 end
 
 Rake::GemPackageTask.new(specification) do |package|

data/TODO

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

data/VERSION

@@ -1 +1 @@
-0.2.0
+1.0.0

data/bin/deep_test

@@ -0,0 +1,15 @@
+#! /usr/bin/env ruby
+
+script_dir = File.dirname(__FILE__) + '/../script/public'
+script_file = script_dir + "/#{ARGV.shift}.rb"
+
+unless File.exist?(script_file)
+  puts 'Usage: deep_test <script> [arguments]'
+  puts '  Available Scripts: '
+  Dir.glob(script_dir + '/*.rb').each do |name|
+    puts "    #{File.basename(name, '.rb')}"
+  end
+  exit(1)
+end
+
+load script_file