osc-machete 1.1.3

data/test/test_job_dir.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+require 'osc/machete'
+
+class TestJobDir < Minitest::Test
+  def setup
+    @data_root = Dir.mktmpdir
+    @parent = Pathname.new(@data_root).join("containers")
+  end
+  
+  def teardown
+    FileUtils.remove_entry @data_root
+  end
+  
+  # test and verify if we create a JobDir helper
+  # with a parent directory that doesn't yet exist
+  # new_jobdir returns  /path/to/parent/1
+  def test_job_dir_with_missing_parent_dir
+    dirhelper = OSC::Machete::JobDir.new(@parent)
+    
+    assert_equal [], dirhelper.jobdirs
+    assert_equal [], dirhelper.targetdirs
+    assert_equal @parent.join("1"), dirhelper.new_jobdir
+  end
+
+  def test_new_jobdir_succeeds_with_numbered_directories
+    FileUtils.mkdir_p @parent
+    
+    # Initialize app directory with multiple jobs
+    # and a file with a larger number
+    Dir.mkdir("#{@parent}/1")
+    Dir.mkdir("#{@parent}/5")
+    FileUtils.touch("#{@parent}/8")
+    
+    # Create unique directory
+    new_jobdir = OSC::Machete::JobDir.new(@parent).new_jobdir
+    Dir.mkdir(new_jobdir)
+    assert Dir.exists?("#{@parent}/9"), "Directory was not created: #{@parent}/9"
+  end
+end

data/test/test_location.rb

@@ -0,0 +1,97 @@
+require 'minitest/autorun'
+require 'osc/machete'
+
+class TestLocation < Minitest::Test
+
+  def setup
+    # tmp directory
+    # and we are making a location object that wraps that directory
+    # we add mustache templates and test rendering
+    # we add another tmp directory/location and we test copy to
+    @dir1 = Dir.mktmpdir("location")
+    @dir2 = Dir.mktmpdir("location")
+    @location1 = OSC::Machete::Location.new(@dir1)
+    @location2 = OSC::Machete::Location.new(@dir2)
+  end
+
+  def teardown
+    FileUtils.remove_entry @dir1
+    FileUtils.remove_entry @dir2
+  end
+
+  # Location.render(params, options = {})
+
+  def test_render_default_replace_template
+    setup_render
+    @location1.render("")
+    assert_equal true,  File.exists?("#{@dir1}/file.txt")
+    assert_equal false, File.exists?("#{@dir1}/file.txt.mustache")
+  end
+
+  def test_render_user_replace_template
+    setup_render
+    @location1.render("", {replace: true})
+    assert_equal true,  File.exists?("#{@dir1}/file.txt")
+    assert_equal false, File.exists?("#{@dir1}/file.txt.mustache")
+  end
+
+  def test_render_user_doesnt_replace_template
+    setup_render
+    @location1.render("", {replace: false})
+    assert_equal true,  File.exists?("#{@dir1}/file.txt")
+    assert_equal true,  File.exists?("#{@dir1}/file.txt.mustache")
+  end
+
+  def test_copy_to_shouldnt_copy_developer_files
+    setup_copy_to
+    
+    @location1.copy_to(@dir2)
+    assert_equal true,  Dir.exists?("#{@dir2}")
+    assert_equal false, Dir.exists?("#{@dir2}/.git")
+    assert_equal false, Dir.exists?("#{@dir2}/.svn")
+    assert_equal false, Dir.exists?("#{@dir2}/test.dir.1")
+    assert_equal true,  Dir.exists?("#{@dir2}/test.dir.2")
+    assert_equal true,  File.exists?("#{@dir2}/test.1")
+    assert_equal false, File.exists?("#{@dir2}/test.2")
+    assert_equal true,  File.exists?("#{@dir2}/test.3")
+    assert_equal false, File.exists?("#{@dir2}/test.4")
+    assert_equal false, File.exists?("#{@dir2}/test.dir.2/test.1")
+    assert_equal false, File.exists?("#{@dir2}/test.dir.2/test.2")
+    assert_equal true,  File.exists?("#{@dir2}/test.dir.2/test.4")
+    assert_equal false, File.exists?("#{@dir2}/.gitignore")
+  end
+  
+  
+  private
+
+    def setup_render
+      FileUtils.touch("#{@dir1}/file.txt.mustache")
+    end
+
+    def setup_copy_to
+      # Example directory/file structure of developer
+      Dir.mkdir("#{@dir1}/.git")
+      Dir.mkdir("#{@dir1}/.svn")
+      Dir.mkdir("#{@dir1}/test.dir.1")
+      Dir.mkdir("#{@dir1}/test.dir.2")
+      FileUtils.touch("#{@dir1}/test.1")
+      FileUtils.touch("#{@dir1}/test.2")
+      FileUtils.touch("#{@dir1}/test.3")
+      FileUtils.touch("#{@dir1}/test.4")
+      FileUtils.touch("#{@dir1}/test.dir.2/test.1")
+      FileUtils.touch("#{@dir1}/test.dir.2/test.2")
+      FileUtils.touch("#{@dir1}/test.dir.2/test.4")
+
+      # Make example .gitignore
+      gitignore = <<-END.gsub(/^ {20}/, '')
+                    # All files here will be ignored
+                    test.2
+                    #test.3
+                    /test.4
+                    test.dir.1
+                    test.dir.2/test.1
+                  END
+
+      File.open("#{@dir1}/.gitignore", 'w') {|f| f.write(gitignore) }
+    end
+end

data/test/test_status.rb

@@ -0,0 +1,99 @@
+require 'minitest/autorun'
+require 'osc/machete'
+
+class TestStatus < Minitest::Test
+  include OSC::Machete
+  
+  def setup
+    @passed = Status.passed
+    @running = Status.running
+    @held = Status.held
+    @queued = Status.queued
+    @failed = Status.failed
+    @new = Status.not_submitted
+    @suspended = Status.suspended
+    @undetermined = Status.undetermined
+  end
+  
+  def teardown
+  end
+  
+  def test_status_equality
+    assert Status.new(:F).eql?(Status.new("F"))
+    assert_equal Status.new(:F), Status.new("F")
+    assert_equal @failed, Status.new("F")
+    assert_equal @passed, Status.new("C")
+    
+    #FIXME: is supporting comparisons between Status values and Strings a good idea?
+    assert_equal @passed, "C"
+    
+    # default value is 
+    assert_equal Status.new(""), @new
+    assert_equal Status.new(nil), @new
+    assert_nil @new.char
+  end
+  
+  def test_to_s
+    assert_equal "Passed", @passed.to_s
+    assert_equal "Not Submitted", @new.to_s
+    assert_equal "Running", @running.to_s
+  end
+
+  def test_create_status_value_from_status_value
+    assert_equal @passed, OSC::Machete::Status.new(@passed)
+  end
+  
+  def test_helpers
+    assert_equal false, @passed.active?
+    assert_equal true, @passed.completed?
+    assert_equal true, @passed.passed?
+    assert_equal true, @queued.queued?
+    assert_equal true, @queued.active?
+  end
+  
+  def test_max
+    assert_equal @passed, [@passed, @passed].max
+    assert_equal @passed, [@new, @passed].max
+    assert_equal @running, [@running, @queued].max
+    assert_equal @failed, [@passed, @failed].max
+    assert_equal @running, [@passed, @running].max
+    assert_equal @running, [@running, @queued].max
+    assert_equal @queued, [@new, @queued].max
+  end
+  
+  def test_add
+    assert_equal @passed, @passed + @passed
+    assert_equal @passed, @new + @passed
+    assert_equal @running, @running + @queued
+    assert_equal @failed, @passed + @failed
+    assert_equal @running, @passed + @running
+    assert_equal @running, @running + @queued
+    assert_equal @queued, @new + @queued
+  end
+
+  def test_undetermined
+    assert_equal Status.new("X"), Status.undetermined
+  end
+
+  def test_submitted
+    assert @passed.submitted?
+    assert @running.submitted?
+    assert @queued.submitted?
+    assert @failed.submitted?
+    assert @passed.submitted?
+    assert ! @new.submitted?
+    assert ! Status.undetermined.submitted?
+  end
+
+  def test_active_status_values
+    assert_equal Status.values.sort, [@undetermined, @new, @passed, @failed, @held, @queued, @running, @suspended].sort
+    assert_equal Status.active_values.sort, [@running, @queued, @held, @suspended].sort
+  end
+
+  def test_completed
+    assert_equal Status.completed_values.sort, [@passed, @failed]
+    assert @passed.completed?
+    assert @failed.completed?
+    assert ! @running.completed?
+  end
+end

data/test/test_torque_helper.rb

@@ -0,0 +1,209 @@
+require 'minitest/autorun'
+require 'osc/machete'
+require 'pbs'
+require 'mocha/setup'
+
+# test helper class
+class TestTorqueHelper < Minitest::Test
+
+  # FIXME:
+  # will be replacing with programmatic access to torque
+  # however... we should have our tests actually submit tiny jobs on a queue that can respond immediately,
+  # run for a minute, and die
+  # perhaps using the Oxymoron cluster for this purpose?
+  #
+  # 2016/01/08  Implemented this in `test_qsub_oakley` and `test_qsub_ruby`. The test only runs when rake
+  #             is called on the correct submit host. On all other systems, only the stubs are used.
+
+  def setup
+    # FIXME: Torque only works from websvsc02
+    #   This raises an issue mentioning that it is not being submitted on the
+    #   correct host, comment out the raise to skip the live tests.
+    #   Maybe this would be better accomplished with a separate rake task.
+    @submit_host = "websvcs02.osc.edu"
+
+    @job_state_queued = OSC::Machete::Status.queued
+    @job_state_completed = OSC::Machete::Status.passed
+    @job_state_running = OSC::Machete::Status.running
+    @job_state_undetermined = OSC::Machete::Status.undetermined
+
+    @shell = OSC::Machete::TorqueHelper.new
+
+    # test staging using HSP template
+    #@params = YAML.load(File.read('test/fixtures/app-params.yml'))
+    #@template = 'test/fixtures/app-template'
+    #@expected = 'test/fixtures/app-template-rendered'
+
+    # directory where to create jobs
+    #@target = Dir.mktmpdir
+    #@script = 'GLO_job'
+
+    @script_oakley = 'test/fixtures/oakley.sh'
+    @script_ruby = 'test/fixtures/ruby.sh'
+  end
+
+  # FIXME: what is the purpose of these tests?
+  # # Test qstat parameters for completed job.
+  # def test_qsub_oakley_stub
+  #   PBS::Job.any_instance.stubs(:submit).with(file: @script_oakley, headers: {}, qsub: true).returns(PBS::Job.new(conn: 'oakley', id: '1234598.oak-batch.osc.edu'))
+  #   assert_equal "1234598.oak-batch.osc.edu", @shell.qsub(@script_oakley)
+  #   PBS::Job.any_instance.unstub(:submit)
+  # end
+
+  # # Test job state parser when returning queued
+  # def test_qsub_ruby_stub
+  #   PBS::Job.any_instance.stubs(:submit).with(file: @script_ruby, headers: {}, qsub: true).returns(PBS::Job.new(conn: 'ruby', id: '1234598'))
+  #   assert_equal "1234598", @shell.qsub(@script_ruby)
+  #   PBS::Job.any_instance.unstub(:submit)
+  # end
+  
+  def test_qstat_state_no_job
+    PBS::Job.any_instance.stubs(:status).raises(PBS::UnkjobidError, "Unknown Job Id")
+    assert_equal @job_state_completed, @shell.qstat("")
+    assert_equal @job_state_completed, @shell.qstat(nil)
+    PBS::Job.any_instance.unstub(:status)
+  end
+
+  # Test that qstat returns Running job StatusValue
+  def test_qstat_state_running_oakley
+    PBS::Job.any_instance.stubs(:status).returns({ :attribs => { :job_state => "R" }})
+    assert_equal @job_state_running, @shell.qstat("123.oak-batch.osc.edu")
+    PBS::Job.any_instance.unstub(:status)
+  end
+
+  # Test that qstat returns Queued job StatusValue
+  def test_qstat_state_queued_oakley
+    PBS::Job.any_instance.stubs(:status).returns({ :attribs => { :job_state => "Q" }})
+    assert_equal @job_state_queued, @shell.qstat("123.oak-batch.osc.edu")
+    PBS::Job.any_instance.unstub(:status)
+  end
+
+  # Test that qstat returns Queued job StatusValue
+  def test_qstat_state_running_ruby
+    PBS::Job.any_instance.stubs(:status).returns({ :attribs => { :job_state => "Q" }})
+    assert_equal @job_state_queued, @shell.qstat("12398765")
+    PBS::Job.any_instance.unstub(:status)
+  end
+
+  # Test that qstat returns Completed job StatusValue when state is nil.
+  def test_qstat_state_completed_oakley
+    PBS::Job.any_instance.stubs(:status).raises(PBS::UnkjobidError, "Unknown Job Id Error")
+    assert_equal @job_state_completed, @shell.qstat("123.oak-batch.osc.edu")
+    PBS::Job.any_instance.unstub(:status)
+
+    PBS::Job.any_instance.stubs(:status).raises(PBS::UnkjobidError, "Unknown Job Id")
+    assert_equal @job_state_completed, @shell.qstat("123.oak-batch.osc.edu")
+    PBS::Job.any_instance.unstub(:status)
+  end
+
+  # Test that qdel works for oakley
+  def test_qdel_oakley_ok
+    PBS::Job.any_instance.stubs(:delete).returns(true)
+    assert_equal true, @shell.qdel("123.oak-batch.osc.edu")
+    PBS::Job.any_instance.unstub(:delete)
+  end
+
+  # Test that qdel works for quick batch
+  def test_qdel_quick
+    PBS::Job.any_instance.stubs(:delete).returns(true)
+    assert_equal true, @shell.qdel("123.quick-batch.osc.edu")
+    PBS::Job.any_instance.unstub(:delete)
+  end
+
+  # Test that qdel works for Ruby cluster
+  def test_qdel_ruby
+    PBS::Job.any_instance.stubs(:delete).returns(true)
+    assert_equal true, @shell.qdel("12365478")
+    PBS::Job.any_instance.unstub(:delete)
+  end
+
+  # Test that qdel throws exception on PBS exception
+  def test_qdel_throws_exception
+    PBS::Job.any_instance.stubs(:delete).raises(PBS::Error)
+    assert_raises(PBS::Error) { @shell.qdel("123.quick-batch.osc.edu") }
+    PBS::Job.any_instance.unstub(:delete)
+
+    PBS::Job.any_instance.stubs(:delete).raises(PBS::SystemError)
+    assert_raises(PBS::SystemError) { @shell.qdel("123.quick-batch.osc.edu") }
+    PBS::Job.any_instance.unstub(:delete)
+  end
+
+  # Test that qdel doesn't throw exception if Unknown Job Id exception
+  def test_qdel_doesnt_throw_exception_on_unknown_job_id
+    PBS::Job.any_instance.stubs(:delete).raises(PBS::UnkjobidError)
+    @shell.qdel("123.quick-batch.osc.edu")
+    PBS::Job.any_instance.unstub(:delete)
+  end
+  
+  def assert_qsub_dependency_list(dependency_list, dependencies, host=nil)
+    assert_equal dependency_list, @shell.qsub_dependencies_header(dependencies)
+  end
+  
+  def test_qsub_afterany
+    assert_qsub_dependency_list("afterany:1234.oak-batch.osc.edu", { afterany: ["1234.oak-batch.osc.edu"] })
+    assert_qsub_dependency_list("afterany:1234.oakbatch.osc.edu", { afterany: "1234.oakbatch.osc.edu" })
+    assert_qsub_dependency_list("afterany:1234.oakbatch.osc.edu:2345.oakbatch.osc.edu", { afterany: ["1234.oakbatch.osc.edu", "2345.oakbatch.osc.edu"] })
+    return true
+  end
+  
+
+  def test_qsub_afterok
+    assert_qsub_dependency_list("afterok:1234.oakbatch.osc.edu", { afterok: ["1234.oakbatch.osc.edu"] })
+    assert_qsub_dependency_list("afterok:1234.oakbatch.osc.edu:2345.oakbatch.osc.edu", { afterok: ["1234.oakbatch.osc.edu", "2345.oakbatch.osc.edu"] })
+    return true
+  end
+  
+  # With multiple dependency types, is formatted:
+  #   type[:argument[:argument...][,type:argument...]
+  # i.e. 
+  #   -W depend=afterany:1234.oakbatch.osc.edu,afterok:2345.oakbatch.osc.edu"
+  # 
+  # See qsub manpage for details
+  def test_qsub_afterok_and_afterany
+    assert_qsub_dependency_list("afterany:1234.oakbatch.osc.edu,afterok:2345.oakbatch.osc.edu", { afterany: "1234.oakbatch.osc.edu", afterok: "2345.oakbatch.osc.edu" } )
+    return true
+  end
+  
+  def test_qsub_other
+    assert_qsub_dependency_list("after:1234.oakbatch.osc.edu", { after: ["1234.oakbatch.osc.edu"] })
+    assert_qsub_dependency_list("afternotok:1234.oakbatch.osc.edu:2345.oakbatch.osc.edu", { afternotok: ["1234.oakbatch.osc.edu", "2345.oakbatch.osc.edu"] })
+    return true
+  end
+  
+  def test_qsub_all_dependencies
+    dependencies = {
+      afterany: "1234.oakbatch.osc.edu",
+      afterok: "2345.oakbatch.osc.edu",
+      after: ["2347.oakbatch.osc.edu", "2348.oakbatch.osc.edu"],
+      afternotok: ["2349.oakbatch.osc.edu", "2350.oakbatch.osc.edu", "2351.oakbatch.osc.edu"]
+    }
+    
+    depencencies_str = "afterany:1234.oakbatch.osc.edu"
+    depencencies_str += ",afterok:2345.oakbatch.osc.edu"
+    depencencies_str += ",after:2347.oakbatch.osc.edu:2348.oakbatch.osc.edu"
+    depencencies_str += ",afternotok:2349.oakbatch.osc.edu:2350.oakbatch.osc.edu:2351.oakbatch.osc.edu"
+    
+    assert_qsub_dependency_list(depencencies_str, dependencies)
+    return true
+  end
+
+  def test_account_string_passed_into_qsub_used_during_submit_call
+    PBS::Job.any_instance.expects(:submit).with(has_entry(headers: {Account_Name: "XXX"})).returns(PBS::Job.new(conn: 'oakley', id: '1234598.oak-batch.osc.edu'))
+    @shell.qsub(@script_oakley, account_string: "XXX")
+    PBS::Job.any_instance.unstub(:submit)
+  end
+
+  def test_default_account_string_used_in_qsub_during_submit_call
+    @shell.stubs(:default_account_string).returns("PZS3000")
+
+    PBS::Job.any_instance.expects(:submit).with(has_entry(headers: {Account_Name: @shell.default_account_string})).returns(PBS::Job.new(conn: 'oakley', id: '1234598.oak-batch.osc.edu'))
+    @shell.qsub(@script_oakley)
+
+    @shell.stubs(:default_account_string).returns("appl")
+    PBS::Job.any_instance.expects(:submit).with(has_entry(headers: {})).returns(PBS::Job.new(conn: 'oakley', id: '1234598.oak-batch.osc.edu'))
+    @shell.qsub(@script_oakley)
+
+    PBS::Job.any_instance.unstub(:submit)
+    @shell.unstub(:default_account_string)
+  end
+end

data/test/test_torque_helper_live.rb

@@ -0,0 +1,174 @@
+require 'minitest/autorun'
+require 'osc/machete'
+require 'pbs'
+require 'mocha/setup'
+
+# test helper class
+class TestTorqueHelperLive < Minitest::Test
+
+  # FIXME:
+  #   All of our tests here are broken after updating to PBS
+  #   Everything will need to be revisited.
+
+  # FIXME:
+  # will be replacing with programmatic access to torque
+  # however... we should have our tests actually submit tiny jobs on a queue that can respond immediately,
+  # run for a minute, and die
+  # perhaps using the Oxymoron cluster for this purpose?
+  #
+  # 2016/01/08  Implemented this in `test_qsub_oakley` and `test_qsub_ruby`. The test only runs when rake
+  #             is called on the correct submit host. On all other systems, only the stubs are used.
+  #
+  def live_test_enabled?
+    ! ENV['LIVETEST'].nil?
+  end
+
+  def setup
+
+    # FIXME: Torque only works from websvsc02
+    #   This raises an issue mentioning that it is not being submitted on the
+    #   correct host, comment out the raise to skip the live tests.
+    #   Maybe this would be better accomplished with a separate rake task.
+    @submit_host = "websvcs02.osc.edu"
+
+    @job_state_queued = OSC::Machete::Status.queued
+    @job_state_completed = OSC::Machete::Status.passed
+    @job_state_running = OSC::Machete::Status.running
+
+    @shell = OSC::Machete::TorqueHelper.new
+
+    # test staging using HSP template
+    #@params = YAML.load(File.read('test/fixtures/app-params.yml'))
+    #@template = 'test/fixtures/app-template'
+    #@expected = 'test/fixtures/app-template-rendered'
+
+    # directory where to create jobs
+    #@target = Dir.mktmpdir
+    #@script = 'GLO_job'
+
+    @script_oakley = 'test/fixtures/oakley.sh'
+    @script_ruby = 'test/fixtures/ruby.sh'
+    @script_quick = 'test/fixtures/quick.sh'
+  end
+
+  # This tests an actual live workflow by
+  #   submitting a job to oakley,
+  #   checking it's status, and
+  #   deleting it.
+  #
+  # Only works on the current submit host.
+  def test_qsub_oakley
+    return unless live_test_enabled?
+
+    torque = OSC::Machete::TorqueHelper.new
+
+    # Don't run the tests if the host doesn't match.
+    if Socket.gethostname == @submit_host
+      # Submit a small job.
+      live_job = torque.qsub(@script_oakley)
+      assert_match(/\d+.oak-batch.osc.edu/, live_job)
+
+      # Qstat it to make sure it's queued.
+      live_status = torque.qstat(live_job)
+      assert_equal @job_state_queued, live_status
+
+      # Delete it and assert true returned.
+      live_delete_status = torque.qdel(live_job)
+      assert_equal nil, live_delete_status
+    else
+      puts "Run test 'test_qsub_oakley' on the batch system from #{@submit_host}."
+    end
+
+  end
+
+  # This tests an actual live workflow by
+  #   submitting a job to ruby with an oakley script,
+  #   checking it's status, and
+  #   deleting it.
+  #
+  # Only works on the current submit host.
+  def test_qsub_ruby_with_oakley_script
+    return unless live_test_enabled?
+
+    torque = OSC::Machete::TorqueHelper.new
+
+    # Don't run the tests if the host doesn't match.
+    if Socket.gethostname == @submit_host
+      # Submit a small job to ruby using an Oakley script,
+      # ensuring that we are no longer evaluating the headers.
+      live_job = torque.qsub(@script_oakley, host: "ruby")
+      assert_match(/\d+$/, live_job)
+
+      # Qstat it to make sure it's queued.
+      live_status = torque.qstat(live_job)
+      assert_equal @job_state_queued, live_status
+
+      # Delete it and assert true returned.
+      live_delete_status = torque.qdel(live_job)
+      assert_equal nil, live_delete_status
+    else
+      puts "Run test 'test_qsub_ruby_with_oakley_script' on the batch system from #{@submit_host}."
+    end
+
+  end
+
+  # This tests an actual live workflow by
+  #   submitting a job to ruby,
+  #   checking it's status, and
+  #   deleting it.
+  #
+  # Only works on the current submit host.
+  def test_qsub_ruby
+    return unless live_test_enabled?
+
+    torque = OSC::Machete::TorqueHelper.new
+
+    # Don't run the tests if the host doesn't match.
+    if Socket.gethostname == @submit_host
+      # Submit a small job.
+      live_job = torque.qsub(@script_ruby)
+      assert_match /^\d+$/, live_job
+
+      # Qstat it to make sure it's queued.
+      live_status = torque.qstat(live_job)
+      assert_equal @job_state_queued, live_status
+
+      # Delete it and assert true returned.
+      live_delete_status = torque.qdel(live_job)
+      assert_equal nil, live_delete_status
+    else
+      puts "Run test 'test_qsub_ruby' on the batch system from #{@submit_host}."
+    end
+  end
+
+  # This tests an actual live workflow by
+  #   submitting a job to quick,
+  #   checking it's status, and
+  #   deleting it.
+  #
+  # Only works on the current submit host.
+  def test_qsub_quick
+    return unless live_test_enabled?
+
+    torque = OSC::Machete::TorqueHelper.new
+
+    # Don't run the tests if the host doesn't match.
+    if Socket.gethostname == @submit_host
+      # Submit a small job.
+      live_job = torque.qsub(@script_quick, host: 'quick')
+      assert_match /\d+.quick-batch.osc.edu/, live_job
+
+      # Qstat it to make sure it's queued.
+      live_status = torque.qstat(live_job)
+      assert_equal @job_state_queued, live_status
+
+      # Delete it and assert true returned.
+      live_delete_status = torque.qdel(live_job)
+      assert_equal nil, live_delete_status
+    else
+      puts "Run test 'test_qsub_quick' on the batch system from #{@submit_host}."
+    end
+  end
+
+
+end