causes-hydra 0.21.0

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,153 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+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
+      pid = Process.fork do
+        # need to get into the fixtures directory so cucumber doesn't load up the whole project
+        Dir.chdir(File.join(File.dirname(__FILE__), 'fixtures'))
+
+        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
+
+    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
+  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)
+      pipe.identify_as_child
+      Hydra::Runner.new(:io => pipe)
+    end
+  end
+  include RunnerTestHelper
+end
+

data/test/ssh_test.rb

@@ -0,0 +1,14 @@
+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
+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.tmpdir, 'hydra', 'local')
+      remote = File.join(Dir.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.tmpdir, 'hydra', 'local')
+      remote_a = File.join(Dir.tmpdir, 'hydra', 'remote_a')
+      remote_b = File.join(Dir.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/test_helper.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'tmpdir'
+
+$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.tmpdir, 'hydra_test.txt'))
+  end
+  
+  def alternate_target_file
+    File.expand_path(File.join(Dir.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
+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
+

data/test/worker_test.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class WorkerTest < Test::Unit::TestCase
+  context "with a file to test and a destination to verify" do
+    setup do
+      FileUtils.rm_f(target_file)
+    end
+
+    teardown do
+      FileUtils.rm_f(target_file)
+    end
+
+    # run the worker in the foreground and the requests in the background
+    should "run a test in the foreground" do
+      num_runners = 4
+      pipe = Hydra::Pipe.new
+      child = Process.fork do
+        request_a_file_and_verify_completion(pipe, num_runners)
+      end
+      run_the_worker(pipe, num_runners)
+      Process.wait(child)
+    end
+
+    # inverse of the above test to run the worker in the background
+    should "run a test in the background" do
+      num_runners = 4
+      pipe = Hydra::Pipe.new
+      child = Process.fork do
+        run_the_worker(pipe, num_runners)
+      end
+      request_a_file_and_verify_completion(pipe, num_runners)
+      Process.wait(child)
+    end
+  end
+
+  module WorkerTestHelper
+    def run_the_worker(pipe, num_runners)
+      pipe.identify_as_child
+      Hydra::Worker.new({:io => pipe, :runners => num_runners})
+    end
+
+    def request_a_file_and_verify_completion(pipe, num_runners)
+      pipe.identify_as_parent
+      pipe.gets # grab the WorkerBegin
+      num_runners.times do
+        response = pipe.gets # grab the RequestFile
+        assert response.is_a?(Hydra::Messages::Worker::RequestFile), "Expected RequestFile but got #{response.class.to_s}"
+      end
+      pipe.write(Hydra::Messages::Master::RunFile.new(:file => test_file))
+
+      assert pipe.gets.is_a?(Hydra::Messages::Worker::Results)
+
+      pipe.write(Hydra::Messages::Master::Shutdown.new)
+
+      assert File.exists?(target_file)
+      assert_equal "HYDRA", File.read(target_file)
+    end
+  end
+  include WorkerTestHelper
+end