ngauthier-hydra 0.24.0

data/lib/hydra/tmpdir.rb

@@ -0,0 +1,11 @@
+require 'tmpdir'
+
+class Dir
+  def self.consistent_tmpdir
+    if RUBY_PLATFORM =~ /darwin/i
+      '/tmp' # OS X normally returns a crazy tmpdir, BUT when logged in via SSH, it is '/tmp'. This unifies it.
+    else
+      Dir.tmpdir
+    end
+  end
+end

data/lib/hydra/trace.rb

@@ -0,0 +1,24 @@
+module Hydra #:nodoc:
+  # Trace output when in verbose mode.
+  module Trace
+    module ClassMethods
+      # Make a class traceable. Takes one parameter,
+      # which is the prefix for the trace to identify this class
+      def traceable(prefix = self.class.to_s)
+        include Hydra::Trace::InstanceMethods
+        class << self; attr_accessor :_traceable_prefix; end
+        self._traceable_prefix = prefix
+        $stdout.sync = true
+      end
+    end
+
+    module InstanceMethods
+      # Trace some output with the class's prefix and a newline.
+      # Checks to ensure we're running verbosely.
+      def trace(str)
+        $stdout.write "#{Time.now.to_f} #{self.class._traceable_prefix}| #{str}\n" if @verbose
+      end
+    end
+  end
+end
+Object.extend(Hydra::Trace::ClassMethods)

data/lib/hydra/version.rb

@@ -0,0 +1,3 @@
+module Hydra
+  VERSION = "0.0.1"
+end

data/lib/hydra/worker.rb

@@ -0,0 +1,170 @@
+module Hydra #:nodoc:
+  # Hydra class responsible to dispatching runners and communicating with the master.
+  #
+  # The Worker is never run directly by a user. Workers are created by a
+  # Master to delegate to Runners.
+  #
+  # The general convention is to have one Worker per machine on a distributed
+  # network.
+  class Worker
+    include Hydra::Messages::Worker
+    traceable('WORKER')
+
+    attr_reader :runners
+    # Create a new worker.
+    # * io: The IO object to use to communicate with the master
+    # * num_runners: The number of runners to launch
+    def initialize(opts = {})
+      @verbose = opts.fetch(:verbose) { false }
+      @io = opts.fetch(:io) { raise "No IO Object" }
+      @runners = []
+      @listeners = []
+      @options = opts.fetch(:options) { "" }
+
+      load_worker_initializer
+
+      @runner_event_listeners = Array(opts.fetch(:runner_listeners) { nil })
+      @runner_event_listeners.select{|l| l.is_a? String}.each do |l|
+        @runner_event_listeners.delete_at(@runner_event_listeners.index(l))
+        listener = eval(l)
+        @runner_event_listeners << listener if listener.is_a?(Hydra::RunnerListener::Abstract)
+      end
+      @runner_log_file = opts.fetch(:runner_log_file) { nil }
+
+      boot_runners(opts.fetch(:runners) { 1 })
+      @io.write(Hydra::Messages::Worker::WorkerBegin.new)
+
+      process_messages
+
+      @runners.each{|r| Process.wait r[:pid] }
+    end
+
+    def load_worker_initializer
+      if File.exist?('./hydra_worker_init.rb')
+        trace('Requiring hydra_worker_init.rb')
+        require 'hydra_worker_init'
+      else
+        trace('hydra_worker_init.rb not present')
+      end
+    end
+    
+    # message handling methods
+
+    # When a runner wants a file, it hits this method with a message.
+    # Then the worker bubbles the file request up to the master.
+    def request_file(message, runner)
+      @io.write(RequestFile.new)
+      runner[:idle] = true
+    end
+
+    # When the master sends a file down to the worker, it hits this
+    # method. Then the worker delegates the file down to a runner.
+    def delegate_file(message)
+      runner = idle_runner
+      runner[:idle] = false
+      runner[:io].write(RunFile.new(eval(message.serialize)))
+    end
+
+    # When a runner finishes, it sends the results up to the worker. Then the
+    # worker sends the results up to the master.
+    def relay_results(message, runner)
+      runner[:idle] = true
+      @io.write(Results.new(eval(message.serialize)))
+    end
+
+    # When a master issues a shutdown order, it hits this method, which causes
+    # the worker to send shutdown messages to its runners.
+    def shutdown
+      @running = false
+      trace "Notifying #{@runners.size} Runners of Shutdown"
+      @runners.each do |r|
+        trace "Sending Shutdown to Runner"
+        trace "\t#{r.inspect}"
+        r[:io].write(Shutdown.new)
+      end
+      Thread.exit
+    end
+
+    private
+
+    def boot_runners(num_runners) #:nodoc:
+      trace "Booting #{num_runners} Runners"
+      num_runners.times do
+        pipe = Hydra::Pipe.new
+
+        child = SafeFork.fork do
+          pipe.identify_as_child
+          Hydra::Runner.new(:io => pipe, :verbose => @verbose, :runner_listeners => @runner_event_listeners, :runner_log_file => @runner_log_file, :options => @options)
+        end
+        pipe.identify_as_parent
+        @runners << { :pid => child, :io => pipe, :idle => false }
+      end
+      trace "#{@runners.size} Runners booted"
+    end
+
+    # Continuously process messages
+    def process_messages #:nodoc:
+      trace "Processing Messages"
+      @running = true
+
+      Thread.abort_on_exception = true
+
+      process_messages_from_master
+      process_messages_from_runners
+
+      @listeners.each{|l| l.join }
+      @io.close
+      trace "Done processing messages"
+    end
+
+    def process_messages_from_master
+      @listeners << Thread.new do
+        while @running
+          begin
+            message = @io.gets
+            if message and !message.class.to_s.index("Master").nil?
+              trace "Received Message from Master"
+              trace "\t#{message.inspect}"
+              message.handle(self)
+            else
+              trace "Nothing from Master, Pinging"
+              @io.write Ping.new
+            end
+          rescue IOError => ex
+            trace "Worker lost Master"
+            shutdown
+          end
+        end
+      end
+    end
+
+    def process_messages_from_runners
+      @runners.each do |r|
+        @listeners << Thread.new do
+          while @running
+            begin
+              message = r[:io].gets
+              if message and !message.class.to_s.index("Runner").nil?
+                trace "Received Message from Runner"
+                trace "\t#{message.inspect}"
+                message.handle(self, r)
+              end
+            rescue IOError => ex
+              trace "Worker lost Runner [#{r.inspect}]"
+              Thread.exit
+            end
+          end
+        end
+      end
+    end
+
+    # Get the next idle runner
+    def idle_runner #:nodoc:
+      idle_r = nil
+      while idle_r.nil?
+        idle_r = @runners.detect{|runner| runner[:idle]}
+      end
+      return idle_r
+    end
+  end
+end

data/test/fixtures/assert_true.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AssertTrueTest < Test::Unit::TestCase
+  should "be true" do
+    assert true
+  end
+end

data/test/fixtures/config.yml

@@ -0,0 +1,4 @@
+---
+  workers:
+    - type: local
+      runners: 2

data/test/fixtures/conflicting.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+# this test is around to make sure that we handle all the errors
+# that can occur when 'require'ing a test file.
+class SyncTest < Object
+  def test_it_again
+    assert true
+  end
+end
+

data/test/fixtures/features/step_definitions.rb

@@ -0,0 +1,21 @@
+Given /^a target file$/ do
+  @target_file = File.expand_path(File.join(Dir.consistent_tmpdir, 'hydra_test.txt'))
+end
+
+Given /^an alternate target file$/ do
+  @target_file = File.expand_path(File.join(Dir.consistent_tmpdir, 'alternate_hydra_test.txt'))
+end
+
+When /^I write "([^\"]*)" to the file$/ do |text|
+  f = File.new(@target_file, 'w')
+  f.write text
+  f.flush
+  f.close
+end
+
+Then /^"([^\"]*)" should be written in the file$/ do |text|
+  f = File.new(@target_file, 'r')
+  raise 'Did not write to file' unless text == f.read
+  f.close
+end
+

data/test/fixtures/features/write_alternate_file.feature

@@ -0,0 +1,7 @@
+Feature: Write a file
+
+  Scenario: Write to hydra_test.txt
+    Given an alternate target file
+    When I write "HYDRA" to the file
+    Then "HYDRA" should be written in the file
+

data/test/fixtures/features/write_file.feature

@@ -0,0 +1,7 @@
+Feature: Write a file
+
+  Scenario: Write to hydra_test.txt
+    Given a target file
+    When I write "HYDRA" to the file
+    Then "HYDRA" should be written in the file
+

data/test/fixtures/hello_world.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+$stdout.write "{:class=>Hydra::Messages::TestMessage, :text=>\"Hello World\"}\n"
+$stdout.flush

data/test/fixtures/hydra_worker_init.rb

@@ -0,0 +1,2 @@
+require '../test/fixtures/runner_listeners.rb'
+require '../test/fixtures/master_listeners.rb'

data/test/fixtures/js_file.js

@@ -0,0 +1,4 @@
+"use strict";
+var thisvar;
+var thatvar
+

data/test/fixtures/json_data.json

@@ -0,0 +1,4 @@
+{
+  "var1": "something",
+  "var2": "trailing comma",
+}

data/test/fixtures/many_outputs_to_console.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+10000.times do 
+  $stdout.write "A non-hydra message...\n"
+  $stdout.flush
+end
+
+$stdout.write "{:class=>Hydra::Messages::TestMessage, :text=>\"My message\"}\n"
+$stdout.flush

data/test/fixtures/master_listeners.rb

@@ -0,0 +1,10 @@
+module HydraExtension
+  module Listener
+    class WorkerBeganFlag < Hydra::Listener::Abstract
+      # Fired after runner processes have been started
+      def worker_begin(worker)
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'worker_began_flag'))
+      end
+    end
+  end
+end

data/test/fixtures/runner_listeners.rb

@@ -0,0 +1,23 @@
+module HydraExtension
+  module RunnerListener
+    class RunnerBeginTest < Hydra::RunnerListener::Abstract
+      # Fired by the runner just before requesting the first file
+      def runner_begin( runner )
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'alternate_hydra_test.txt'))
+      end
+    end
+
+    class RunnerEndTest < Hydra::RunnerListener::Abstract
+      # Fired by the runner just before requesting the first file
+      def runner_begin( runner )
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'runner_began_flag')) #used to know when the runner is ready
+      end
+      # Fired by the runner just after stoping
+      def runner_end( runner )
+        # NOTE: do not use trace here
+        #runner.trace "Ending runner"
+        FileUtils.touch File.expand_path(File.join(Dir.consistent_tmpdir, 'alternate_hydra_test.txt'))
+      end
+    end
+  end
+end

data/test/fixtures/slow.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class WriteFileTest < Test::Unit::TestCase
+  def test_slow
+    sleep(5)
+  end
+end
+
+

data/test/fixtures/sync_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class SyncTest < Test::Unit::TestCase
+  def test_truth
+    assert true
+  end
+end
+

data/test/fixtures/task_test_config.yml

@@ -0,0 +1,6 @@
+---
+  workers:
+    - type: ssh
+      connect: localhost
+      directory: /tmp
+      runners: 1

data/test/fixtures/write_file.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class WriteFileTest < Test::Unit::TestCase
+  def test_write_a_file
+    File.open(File.join(Dir.consistent_tmpdir, 'hydra_test.txt'), 'a') do |f|
+      f.write "HYDRA"
+    end
+  end
+end
+

data/test/fixtures/write_file_alternate_spec.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'hydra/tmpdir'
+context "file writing" do
+  it "writes to a file" do
+    File.open(File.join(Dir.consistent_tmpdir, 'alternate_hydra_test.txt'), 'a') do |f|
+      f.write "HYDRA"
+    end
+  end
+end
+

data/test/fixtures/write_file_spec.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'hydra/tmpdir'
+context "file writing" do
+  it "writes to a file" do
+    File.open(File.join(Dir.consistent_tmpdir, 'hydra_test.txt'), 'a') do |f|
+      f.write "HYDRA"
+    end
+  end
+end

data/test/fixtures/write_file_with_pending_spec.rb

@@ -0,0 +1,11 @@
+require 'tmpdir'
+require 'rspec'
+context "file writing" do
+  it "writes to a file" do
+    File.open(File.join(Dir.consistent_tmpdir, 'hydra_test.txt'), 'a') do |f|
+      f.write "HYDRA"
+    end
+  end
+  it 'could do so much more'  # pending spec
+end
+

data/test/master_test.rb

@@ -0,0 +1,383 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+require File.join(File.dirname(__FILE__), 'fixtures', 'runner_listeners')
+require File.join(File.dirname(__FILE__), 'fixtures', 'master_listeners')
+
+class MasterTest < 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 "run a test" do
+      Hydra::Master.new(
+        :files => [test_file]
+      )
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
+    end
+
+    # this test simulates what happens when we have 2 tests with the same
+    # class name but with different parent classes.  This can happen when 
+    # we have a functional and an integration test class with the same name.
+    should "run even with a test that will not require" do
+      class FileOutputListener < Hydra::Listener::Abstract
+        attr_accessor :output
+        def initialize(&block)
+          self.output = {}
+        end
+
+        def file_end(file, output)
+          self.output[file] = output
+        end
+      end
+
+      listener =  FileOutputListener.new
+      sync_test = File.join(File.dirname(__FILE__), 'fixtures', 'sync_test.rb')
+      Hydra::Master.new(
+        # we want the actual test to run last to make sure the runner can still run tests
+        :files => [sync_test, conflicting_test_file, test_file],
+        :autosort => false,
+        :listeners => [listener]
+      )
+      assert_match /superclass mismatch for class SyncTest/, listener.output[conflicting_test_file]
+      assert_match conflicting_test_file, listener.output[conflicting_test_file]
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
+    end
+
+    should "run a spec with pending examples" do
+      progress_bar = Hydra::Listener::ProgressBar.new(StringIO.new)
+      Hydra::Master.new(
+        :files => [rspec_file_with_pending],
+        :listeners => [progress_bar]
+      )
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
+      assert_equal false, progress_bar.instance_variable_get('@errors')
+    end
+
+    should "generate a report" do
+      Hydra::Master.new(:files => [test_file])
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
+      report_file = File.join(Dir.consistent_tmpdir, 'hydra_heuristics.yml')
+      assert File.exists?(report_file)
+      assert report = YAML.load_file(report_file)
+      assert_not_nil report[test_file]
+    end
+
+    should "run a test 6 times on 1 worker with 2 runners" do
+      Hydra::Master.new(
+        :files => [test_file]*6,
+        :workers => [ { :type => :local, :runners => 2 } ]
+      )
+      assert File.exists?(target_file)
+      assert_equal "HYDRA"*6, File.read(target_file)
+    end
+
+    # The test being run sleeps for 5 seconds. So, if this was run in
+    # series, it would take at least 50 seconds. This test ensures that
+    # in runs in less than that amount of time. Since there are 10
+    # runners to run the file 10 times, it should only take 5-10 seconds
+    # based on overhead.
+    should "run a slow test 10 times on 1 worker with 10 runners quickly" do
+      start = Time.now
+      Hydra::Master.new(
+        :files => [File.join(File.dirname(__FILE__), 'fixtures', 'slow.rb')]*10,
+        :workers => [
+          { :type => :local, :runners => 10 }
+        ]
+      )
+      finish = Time.now
+      assert (finish-start) < 30, "took #{finish-start} seconds"
+    end
+
+    should "run a slow test 10 times on 2 workers with 5 runners each quickly" do
+      start = Time.now
+      Hydra::Master.new(
+        :files => [File.join(File.dirname(__FILE__), 'fixtures', 'slow.rb')]*10,
+        :workers => [
+          { :type => :local, :runners => 5 },
+          { :type => :local, :runners => 5 }
+        ]
+      )
+      finish = Time.now
+      assert (finish-start) < 15, "took #{finish-start} seconds"
+    end
+
+    should "run a test via ssh" do
+      Hydra::Master.new(
+        :files => [test_file],
+        :workers => [{
+          :type => :ssh,
+          :connect => 'localhost',
+          :directory => remote_dir_path,
+          :runners => 1
+        }]
+      )
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
+    end
+
+    should "run a test with config from a yaml file" do
+      Hydra::Master.new(
+        :files => [test_file],
+        :config => File.join(File.dirname(__FILE__), 'fixtures', 'config.yml')
+      )
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(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::Master.new(
+        :files => ['test_a.rb'],
+        :workers => [{
+          :type => :ssh,
+          :connect => 'localhost',
+          :directory => remote,
+          :runners => 1
+        }],
+        :sync => {
+          :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
+  end
+
+  context "with a runner_end event" do
+    setup do
+      # avoid having other tests interfering with us
+      sleep(0.2)
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(alternate_target_file)
+
+      @runner_began_flag = File.expand_path(File.join(Dir.consistent_tmpdir, 'runner_began_flag')) #used to know when the worker is ready
+      FileUtils.rm_f(@runner_began_flag)
+
+      @runner_listener = 'HydraExtension::RunnerListener::RunnerEndTest.new' # runner_end method that creates alternate_target_file
+      @master_listener = HydraExtension::Listener::WorkerBeganFlag.new  #used to know when the runner is up
+    end
+
+    teardown do
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(alternate_target_file)
+    end
+
+    context "running a local worker" do
+      should "run runner_end on successful termination" do
+        @pid = Process.fork do
+            Hydra::Master.new(
+              :files => [test_file] * 6,
+              :autosort => false,
+              :listeners => [@master_listener],
+              :runner_listeners => [@runner_listener],
+              :verbose => false
+            )
+          end
+        Process.waitpid @pid
+
+        assert_file_exists alternate_target_file
+      end
+
+      should "run runner_end after interruption signal" do
+        add_infinite_worker_begin_to @master_listener
+
+        capture_stderr do # redirect stderr
+          @pid = Process.fork do
+            Hydra::Master.new(
+              :files => [test_file],
+              :autosort => false,
+              :listeners => [@master_listener],
+              :runner_listeners => [@runner_listener],
+              :verbose => false
+            )
+          end
+        end
+        wait_for_runner_to_begin
+
+        Process.kill 'SIGINT', @pid
+        Process.waitpid @pid
+
+        assert_file_exists alternate_target_file
+      end
+    end
+
+    context "running a remote worker" do
+      setup do
+        copy_worker_init_file # this method has a protection to avoid erasing an existing worker_init_file
+      end
+
+      teardown do
+        FileUtils.rm_f(@remote_init_file) unless @protect_init_file
+      end
+
+      should "run runner_end on successful termination" do
+        capture_stderr do # redirect stderr
+          @pid = Process.fork do
+            Hydra::Master.new(
+              :files => [test_file],
+              :autosort => false,
+              :listeners => [@master_listener],
+              :runner_listeners => [@runner_listener],
+              :workers => [{
+                :type => :ssh,
+                :connect => 'localhost',
+                :directory => remote_dir_path,
+                :runners => 1
+              }],
+              :verbose => false
+            )
+          end
+        end
+        Process.waitpid @pid
+
+        assert_file_exists alternate_target_file
+      end
+    end
+  end
+
+  context "redirecting runner's output and errors" do
+    setup do
+      # avoid having other tests interfering with us
+      sleep(0.2)
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(runner_log_file)
+      FileUtils.rm_f("#{remote_dir_path}/#{runner_log_file}")
+    end
+
+    teardown do
+      FileUtils.rm_f(target_file)
+      FileUtils.rm_f(runner_log_file)
+      FileUtils.rm_f("#{remote_dir_path}/#{runner_log_file}")
+    end
+
+    should "create a runner log file when usign local worker and passing a log file name" do
+      @pid = Process.fork do
+        Hydra::Master.new(
+              :files => [test_file],
+              :runner_log_file => runner_log_file,
+              :verbose => false
+            )
+      end
+      Process.waitpid @pid
+
+      assert_file_exists target_file # ensure the test was successfully ran
+      assert_file_exists runner_log_file
+    end
+
+    should "create a runner log file when usign remote worker and passing a log file name" do
+      @pid = Process.fork do
+        Hydra::Master.new(
+              :files => [test_file],
+              :workers => [{
+                :type => :ssh,
+                :connect => 'localhost',
+                :directory => remote_dir_path,
+                :runners => 1
+              }],
+              :verbose => false,
+              :runner_log_file => runner_log_file
+            )
+      end
+      Process.waitpid @pid
+
+      assert_file_exists target_file # ensure the test was successfully ran
+      assert_file_exists "#{remote_dir_path}/#{runner_log_file}"
+    end
+
+    should "create the default runner log file when passing an incorrect log file path" do
+      default_log_file = "#{remote_dir_path}/#{Hydra::Runner::DEFAULT_LOG_FILE}" # hydra-runner.log"
+      FileUtils.rm_f(default_log_file)
+
+      @pid = Process.fork do
+        Hydra::Master.new(
+              :files => [test_file],
+              :workers => [{
+                :type => :ssh,
+                :connect => 'localhost',
+                :directory => remote_dir_path,
+                :runners => 1
+              }],
+              :verbose => false,
+              :runner_log_file => 'invalid-dir/#{runner_log_file}'
+            )
+      end
+      Process.waitpid @pid
+
+      assert_file_exists target_file # ensure the test was successfully ran
+      assert_file_exists default_log_file #default log file
+      assert !File.exists?( "#{remote_dir_path}/#{runner_log_file}" )
+
+      FileUtils.rm_f(default_log_file)
+    end
+  end
+
+  private
+
+  def runner_log_file
+    "my-hydra-runner.log"
+  end
+
+  def add_infinite_worker_begin_to master_listener
+    class << master_listener
+      def worker_begin( worker )
+        super
+        sleep 1 while true #ensure the process doesn't finish before killing it
+      end
+    end
+  end
+
+  #  this requires that a worker_begin listener creates a file named worker_began_flag in tmp directory
+  def wait_for_runner_to_begin
+    assert_file_exists @runner_began_flag
+  end
+
+  # with a protection to avoid erasing something important in lib
+  def copy_worker_init_file
+    @remote_init_file = "#{remote_dir_path}/#{File.basename( hydra_worker_init_file )}"
+    if File.exists?( @remote_init_file )
+      $stderr.puts "\nWARNING!!!: #{@remote_init_file} exits and this test needs to create a new file here. Make sure there is nothing inportant in that file and remove it before running this test\n\n"
+      @protect_init_file = true
+      exit
+    end
+    # copy the hydra_worker_init to the correct location
+    FileUtils.cp(hydra_worker_init_file, remote_dir_path)
+  end
+end