hydra 0.24.0 → 6.0.0.rc1

data/test/message_test.rb

@@ -1,31 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class MessageTest < Test::Unit::TestCase
-  class MyMessage < Hydra::Message
-    attr_accessor :my_var
-    def serialize
-      super(:my_var => @my_var)
-    end
-  end
-
-  context "with a message" do
-    setup do
-      @m = MyMessage.new(:my_var => 'my value')
-    end
-    should "set values" do
-      assert_equal 'my value', @m.my_var
-    end
-    should "serialize" do
-      assert_equal(
-        {:class=>MyMessage, :my_var=>"my value"},
-        eval(@m.serialize)
-      )
-    end
-    should "build from serialization" do
-      assert_equal(
-        @m.my_var,
-        Hydra::Message.build(eval(@m.serialize)).my_var
-      )
-    end
-  end
-end

data/test/pipe_test.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class PipeTest < Test::Unit::TestCase
-  context "a pipe" do
-    setup do
-      @pipe = Hydra::Pipe.new
-    end
-    teardown do
-      @pipe.close
-    end
-    should "be able to write messages" do
-      child = Process.fork do
-        @pipe.identify_as_child
-        assert_equal "Test Message", @pipe.gets.text
-        @pipe.write Hydra::Messages::TestMessage.new(:text => "Message Received")
-        @pipe.write Hydra::Messages::TestMessage.new(:text => "Second Message")
-      end
-      @pipe.identify_as_parent
-      @pipe.write Hydra::Messages::TestMessage.new(:text => "Test Message")
-      assert_equal "Message Received", @pipe.gets.text
-      assert_equal "Second Message", @pipe.gets.text
-      Process.wait(child) #ensure it quits, so there is nothing to write to
-      assert_raise IOError do
-        @pipe.write Hydra::Messages::TestMessage.new(:text => "anyone there?")
-      end
-    end
-    should "not allow writing if unidentified" do
-      assert_raise IOError do
-        @pipe.write Hydra::Messages::TestMessage.new(:text => "Test Message")
-      end
-    end
-    should "not allow reading if unidentified" do
-      assert_raise IOError do
-        @pipe.gets
-      end
-    end
-  end
-end

data/test/runner_test.rb

@@ -1,196 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-require File.join(File.dirname(__FILE__), 'fixtures', 'runner_listeners')
-
-class RunnerTest < Test::Unit::TestCase
-  context "with a file to test and a destination to verify" do
-    setup do
-      sleep(0.2)
-      FileUtils.rm_f(target_file)
-      FileUtils.rm_f(alternate_target_file)
-    end
-
-    teardown do
-      FileUtils.rm_f(target_file)
-      FileUtils.rm_f(alternate_target_file)
-    end
-
-
-    should "run a test in the foreground" do
-      # flip it around to the parent is in the fork, this gives
-      # us more direct control over the runner and proper test
-      # coverage output
-      pipe = Hydra::Pipe.new
-      parent = Process.fork do
-        request_a_file_and_verify_completion(pipe, test_file)
-      end
-      run_the_runner(pipe)
-      Process.wait(parent)
-    end
-
-    # this flips the above test, so that the main process runs a bit of the parent
-    # code, but only with minimal assertion
-    should "run a test in the background" do
-      pipe = Hydra::Pipe.new
-      child = Process.fork do
-        run_the_runner(pipe)
-      end
-      request_a_file_and_verify_completion(pipe, test_file)
-      Process.wait(child)
-    end
-
-    should "run a js lint file and find errors" do
-      runner = Hydra::Runner.new(:io => File.new('/dev/null', 'w'))
-      results = runner.run_file(javascript_file)
-      assert results =~ /Missing semicolon/, results
-    end
-
-    should "run a json data file and find errors" do
-      runner = Hydra::Runner.new(:io => File.new('/dev/null', 'w'))
-      results = runner.run_file(json_file)
-      assert results =~ /trailing comma/, results
-    end
-
-    should "run two rspec tests" do
-      runner = Hydra::Runner.new(:io => File.new('/dev/null', 'w'))
-      runner.run_file(rspec_file)
-      assert File.exists?(target_file)
-      assert_equal "HYDRA", File.read(target_file)
-
-      FileUtils.rm_f(target_file)
-      
-      runner.run_file(alternate_rspec_file)
-      assert File.exists?(alternate_target_file)
-      assert_equal "HYDRA", File.read(alternate_target_file)
-      assert !File.exists?(target_file), "Tests are double running!"
-    end
-
-    should "run rspec tests with pending examples" do
-      runner = Hydra::Runner.new(:io => File.new('/dev/null', 'w'))
-      assert File.exists?(rspec_file_with_pending)
-
-      runner.run_file(rspec_file_with_pending)
-
-      assert File.exists?(target_file)
-      assert_equal "HYDRA", File.read(target_file)
-
-      FileUtils.rm_f(target_file)
-    end
-
-    should "run two cucumber tests" do
-      # because of all the crap cucumber pulls in
-      # we run this in a fork to not contaminate
-      # the main test environment
-      capture_stderr do # redirect stderr
-        pid = Process.fork do
-          runner = Hydra::Runner.new(:io => File.new('/dev/null', 'w'))
-          runner.run_file(cucumber_feature_file)
-          assert File.exists?(target_file)
-          assert_equal "HYDRA", File.read(target_file)
-
-          FileUtils.rm_f(target_file)
-
-          runner.run_file(alternate_cucumber_feature_file)
-          assert File.exists?(alternate_target_file)
-          assert_equal "HYDRA", File.read(alternate_target_file)
-          assert !File.exists?(target_file)
-        end
-        Process.wait pid
-      end
-    end
-
-    should "be able to run a runner over ssh" do
-      ssh = Hydra::SSH.new(
-        'localhost',
-        File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')),
-        "ruby -e \"require 'rubygems'; require 'hydra'; Hydra::Runner.new(:io => Hydra::Stdio.new, :verbose => true);\""
-      )
-      assert ssh.gets.is_a?(Hydra::Messages::Runner::RequestFile)
-      ssh.write(Hydra::Messages::Worker::RunFile.new(:file => test_file))
-
-      # grab its response. This makes us wait for it to finish
-      echo = ssh.gets # get the ssh echo
-      response = ssh.gets
-
-      assert_equal Hydra::Messages::Runner::Results, response.class
-
-      # tell it to shut down
-      ssh.write(Hydra::Messages::Worker::Shutdown.new)
-
-      ssh.close
-
-      # ensure it ran
-      assert File.exists?(target_file)
-      assert_equal "HYDRA", File.read(target_file)
-    end
-
-    context "using runner events" do
-      context "on successful termination" do
-        setup do
-          @pipe = Hydra::Pipe.new
-          @parent = Process.fork do
-            request_a_file_and_verify_completion(@pipe, test_file)
-          end
-        end
-
-        should "fire runner_begin event" do
-          run_the_runner(@pipe,  [HydraExtension::RunnerListener::RunnerBeginTest.new] )
-          Process.wait(@parent)
-
-          # ensure runner_begin was fired
-          assert_file_exists alternate_target_file
-        end
-
-        should "fire runner_end event" do
-          run_the_runner(@pipe,  [HydraExtension::RunnerListener::RunnerEndTest.new] )
-          Process.wait(@parent)
-
-          assert_file_exists alternate_target_file
-        end
-      end
-
-      should "fire runner_end event after losing communication with worker" do
-        pipe = Hydra::Pipe.new
-        parent = Process.fork do
-          pipe.identify_as_parent
-
-          # grab its response.
-          response = pipe.gets
-          pipe.close #this will be detected by the runner and it should call runner_end
-        end
-
-        run_the_runner(pipe,  [HydraExtension::RunnerListener::RunnerEndTest.new] )
-        Process.wait(parent)
-
-        # ensure runner_end was fired
-        assert File.exists?( alternate_target_file )
-      end
-    end
-  end
-
-  module RunnerTestHelper
-    def request_a_file_and_verify_completion(pipe, file)
-      pipe.identify_as_parent
-
-      # make sure it asks for a file, then give it one
-      assert pipe.gets.is_a?(Hydra::Messages::Runner::RequestFile)
-      pipe.write(Hydra::Messages::Worker::RunFile.new(:file => file))
-      
-      # grab its response. This makes us wait for it to finish
-      response = pipe.gets
-      
-      # tell it to shut down
-      pipe.write(Hydra::Messages::Worker::Shutdown.new)
-      
-      # ensure it ran
-      assert File.exists?(target_file)
-      assert_equal "HYDRA", File.read(target_file)
-    end
-
-    def run_the_runner(pipe, listeners = [])
-      pipe.identify_as_child
-      Hydra::Runner.new( :io => pipe, :runner_listeners => listeners )
-    end
-  end
-  include RunnerTestHelper
-end
-

data/test/ssh_test.rb

@@ -1,25 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class SSHTest < Test::Unit::TestCase
-  should "be able to execute a command over ssh" do
-    ssh = Hydra::SSH.new(
-      'localhost', # connect to this machine
-      File.expand_path(File.join(File.dirname(__FILE__))), # move to the test directory
-      "ruby fixtures/hello_world.rb"
-    )
-    response = ssh.gets
-    assert_equal "Hello World", response.text
-    ssh.close
-  end
-
-  should "be able to handle a large number of non-Hydra console output" do
-    ssh = Hydra::SSH.new(
-      'localhost', # connect to this machine
-      File.expand_path(File.join(File.dirname(__FILE__))), # move to the test directory
-      "ruby fixtures/many_outputs_to_console.rb"
-    )
-    response = ssh.gets
-    assert_equal "My message", response.text
-    ssh.close
-  end
-end

data/test/sync_test.rb

@@ -1,113 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-class SyncTest < Test::Unit::TestCase
-  context "with a file to test and a destination to verify" do
-    setup do
-      # avoid having other tests interfering with us
-      sleep(0.2)
-      #FileUtils.rm_f(target_file)
-    end
-
-    teardown do
-      #FileUtils.rm_f(target_file)
-    end
-
-    should "synchronize a test file over ssh with rsync" do
-      local = File.join(Dir.consistent_tmpdir, 'hydra', 'local')
-      remote = File.join(Dir.consistent_tmpdir, 'hydra', 'remote')
-      sync_test = File.join(File.dirname(__FILE__), 'fixtures', 'sync_test.rb')
-      [local, remote].each{|f| FileUtils.rm_rf f; FileUtils.mkdir_p f}
-
-      # setup the folders:
-      # local:
-      #   - test_a
-      #   - test_c
-      # remote:
-      #   - test_b
-      #
-      # add test_c to exludes
-      FileUtils.cp(sync_test, File.join(local, 'test_a.rb'))
-      FileUtils.cp(sync_test, File.join(local, 'test_c.rb'))
-      FileUtils.cp(sync_test, File.join(remote, 'test_b.rb'))
-
-      # ensure a is not on remote
-      assert !File.exists?(File.join(remote, 'test_a.rb')), "A should not be on remote"
-      # ensure c is not on remote
-      assert !File.exists?(File.join(remote, 'test_c.rb')), "C should not be on remote"
-      # ensure b is on remote
-      assert File.exists?(File.join(remote, 'test_b.rb')),  "B should be on remote"
-
-      Hydra::Sync.new(
-        {
-          :type => :ssh,
-          :connect => 'localhost',
-          :directory => remote,
-          :runners => 1
-        },
-        {
-          :directory => local,
-          :exclude => ['test_c.rb']
-        }
-      )
-      # ensure a is copied
-      assert File.exists?(File.join(remote, 'test_a.rb')), "A was not copied"
-      # ensure c is not copied
-      assert !File.exists?(File.join(remote, 'test_c.rb')), "C was copied, should be excluded"
-      # ensure b is deleted
-      assert !File.exists?(File.join(remote, 'test_b.rb')), "B was not deleted"
-    end
-
-    should "synchronize a test file over ssh with rsync to multiple workers" do
-      local = File.join(Dir.consistent_tmpdir, 'hydra', 'local')
-      remote_a = File.join(Dir.consistent_tmpdir, 'hydra', 'remote_a')
-      remote_b = File.join(Dir.consistent_tmpdir, 'hydra', 'remote_b')
-      sync_test = File.join(File.dirname(__FILE__), 'fixtures', 'sync_test.rb')
-      [local, remote_a, remote_b].each{|f| FileUtils.rm_rf f; FileUtils.mkdir_p f}
-
-      # setup the folders:
-      # local:
-      #   - test_a
-      # remote_a:
-      #   - test_b
-      # remote_b:
-      #   - test_c
-      #
-      # add test_c to exludes
-      FileUtils.cp(sync_test, File.join(local, 'test_a.rb'))
-      FileUtils.cp(sync_test, File.join(remote_a, 'test_b.rb'))
-      FileUtils.cp(sync_test, File.join(remote_b, 'test_c.rb'))
-
-      # ensure a is not on remotes
-      assert !File.exists?(File.join(remote_a, 'test_a.rb')), "A should not be on remote_a"
-      assert !File.exists?(File.join(remote_b, 'test_a.rb')), "A should not be on remote_b"
-      # ensure b is on remote_a
-      assert File.exists?(File.join(remote_a, 'test_b.rb')),  "B should be on remote_a"
-      # ensure c is on remote_b
-      assert File.exists?(File.join(remote_b, 'test_c.rb')),  "C should be on remote_b"
-
-      Hydra::Sync.sync_many(
-        :workers => [{
-          :type => :ssh,
-          :connect => 'localhost',
-          :directory => remote_a,
-          :runners => 1
-        },
-        {
-          :type => :ssh,
-          :connect => 'localhost',
-          :directory => remote_b,
-          :runners => 1
-        }],
-        :sync => {
-          :directory => local
-        }
-      )
-      # ensure a is copied to both remotes
-      assert File.exists?(File.join(remote_a, 'test_a.rb')), "A was not copied to remote_a"
-      assert File.exists?(File.join(remote_b, 'test_a.rb')), "A was not copied to remote_b"
-      # ensure b and c are deleted from remotes
-      assert !File.exists?(File.join(remote_a, 'test_b.rb')), "B was not deleted from remote_a"
-      assert !File.exists?(File.join(remote_b, 'test_c.rb')), "C was not deleted from remote_b"
-    end
-  end
-end

data/test/task_test.rb

@@ -1,21 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-require 'hydra/tasks'
-require 'rake'
-
-class TaskTest < Test::Unit::TestCase
-  context "a task" do
-    should "execute the command in a remote machine" do
-      
-      File.delete( "/tmp/new_file" ) if File.exists? "/tmp/new_file"
-
-      Hydra::RemoteTask.new('cat:text_file', 'touch new_file') do |t|
-        t.config = "test/fixtures/task_test_config.yml"
-      end
-
-      Rake.application['hydra:remote:cat:text_file'].invoke
-
-      assert( File.exists? "/tmp/new_file" )
-      
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,107 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-gem 'shoulda', '2.10.3'
-gem 'rspec', '2.0.0.beta.19'
-require 'shoulda'
-require 'tmpdir'
-require "stringio"
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'hydra'
-
-# Since Hydra turns off testing, we have to turn it back on
-Test::Unit.run = false
-
-class Test::Unit::TestCase
-  def target_file
-    File.expand_path(File.join(Dir.consistent_tmpdir, 'hydra_test.txt'))
-  end
-  
-  def alternate_target_file
-    File.expand_path(File.join(Dir.consistent_tmpdir, 'alternate_hydra_test.txt'))
-  end
-
-  def test_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'write_file.rb'))
-  end
-
-  def rspec_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'write_file_spec.rb'))
-  end
-
-  def alternate_rspec_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'write_file_alternate_spec.rb'))
-  end
-
-  def rspec_file_with_pending
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'write_file_with_pending_spec.rb'))
-  end
-
-  def cucumber_feature_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'features', 'write_file.feature'))
-  end
-
-  def alternate_cucumber_feature_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'features', 'write_alternate_file.feature'))
-  end
-
-  def javascript_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'js_file.js'))
-  end
-
-  def json_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'json_data.json'))
-  end
-
-  def conflicting_test_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'conflicting.rb'))
-  end
-
-  def remote_dir_path
-    File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-  end
-
-  def hydra_worker_init_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'hydra_worker_init.rb'))
-  end
-
-  def capture_stderr
-    # The output stream must be an IO-like object. In this case we capture it in
-    # an in-memory IO object so we can return the string value. You can assign any
-    # IO object here.
-    previous_stderr, $stderr = $stderr, StringIO.new
-    yield
-    $stderr.string
-  ensure
-    # Restore the previous value of stderr (typically equal to STDERR).
-    $stderr = previous_stderr
-  end
-
-  #this method allow us to wait for a file for a maximum number of time, so the
-  #test can pass in slower machines. This helps to speed up the tests
-  def assert_file_exists file, time_to_wait = 2
-    time_begin = Time.now
-
-    until Time.now - time_begin >= time_to_wait or File.exists?( file ) do
-      sleep 0.01
-    end
-
-    assert File.exists?( file )
-  end
-end
-
-module Hydra #:nodoc:
-  module Messages #:nodoc:
-    class TestMessage < Hydra::Message
-      attr_accessor :text
-      def initialize(opts = {})
-        @text = opts.fetch(:text){ "test" }
-      end
-      def serialize
-        super(:text => @text)
-      end
-    end
-  end
-end
-