arturop-hydra 0.23.4

data/test/message_test.rb

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

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

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

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

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

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

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