neptune 0.1.4 → 0.2.0

data/test/unit/test_app_controller_client.rb

@@ -41,7 +41,7 @@ class TestAppControllerClient < Test::Unit::TestCase
     no_retry_on_exception = false
 
     call_number = 0
-    assert_nothing_raised(SystemExit) {
+    assert_nothing_raised(AppControllerException) {
       @client.make_call(no_timeout, retry_on_exception) {
         call_number += 1
         case call_number
@@ -57,13 +57,13 @@ class TestAppControllerClient < Test::Unit::TestCase
       }
     }
 
-    assert_raise(SystemExit) {
+    assert_raise(AppControllerException) {
       @client.make_call(no_timeout, no_retry_on_exception) {
         raise Errno::ECONNREFUSED
       }
     }
 
-    assert_raise(SystemExit) {
+    assert_raise(AppControllerException) {
       @client.make_call(no_timeout, no_retry_on_exception) {
         raise Exception
       }
@@ -76,31 +76,31 @@ class TestAppControllerClient < Test::Unit::TestCase
   # result unless it has 'Error:' in it. If it does, it aborts execution.
   def test_start_neptune_job
     assert(@client.start_neptune_job(@job_data_ok))
-    assert_raise(SystemExit) { @client.start_neptune_job(@job_data_err) }
+    assert_raise(AppControllerException) { @client.start_neptune_job(@job_data_err) }
   end
 
   def test_put_input
     assert(@client.put_input(@job_data_ok))
-    assert_raise(SystemExit) { @client.put_input(@job_data_err) }
+    assert_raise(AppControllerException) { @client.put_input(@job_data_err) }
   end
 
   def test_get_output
     assert(@client.get_output(@job_data_ok))
-    assert_raise(SystemExit) { @client.get_output(@job_data_err) }
+    assert_raise(AppControllerException) { @client.get_output(@job_data_err) }
   end
 
   def test_get_acl
     assert(@client.get_acl(@job_data_ok))
-    assert_raise(SystemExit) { @client.get_acl(@job_data_err) }
+    assert_raise(AppControllerException) { @client.get_acl(@job_data_err) }
   end
 
   def test_set_acl
     assert(@client.set_acl(@job_data_ok))
-    assert_raise(SystemExit) { @client.set_acl(@job_data_err) }
+    assert_raise(AppControllerException) { @client.set_acl(@job_data_err) }
   end
 
   def test_compile_code
     assert(@client.compile_code(@job_data_ok))
-    assert_raise(SystemExit) { @client.compile_code(@job_data_err) }
+    assert_raise(AppControllerException) { @client.compile_code(@job_data_err) }
   end
 end

data/test/unit/test_babel.rb

@@ -0,0 +1,154 @@
+# Programmer: Chris Bunch (cgb@cs.ucsb.edu)
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib")
+require 'babel'
+
+require 'test/unit'
+
+
+class TestBabel < Test::Unit::TestCase
+  def test_bad_babel_params
+    job_data_no_code_param = {}
+    assert_raise(BadConfigurationException) {
+      # Since babel is using futures/promises, the babel invocation won't
+      # actually throw the exception to us unless we use the value in any
+      # way - so just print it, knowing it will never get to stdout.
+      a = babel(job_data_no_code_param)
+      Kernel.puts(a)
+    }
+  end
+
+  def test_generate_output
+    # Since output is generated randomly, make it non-random for now.
+    commonfunctions = flexmock(CommonFunctions)
+    commonfunctions.should_receive(:get_random_alphanumeric).and_return(10)
+
+    job_data_local_code = {"@code" => "boo.rb"}
+
+    # If neither @bucket_name nor the BABEL_BUCKET_NAME env var are specified,
+    # this should fail.
+    assert_raise(BadConfigurationException) {
+      BabelHelper.generate_output_location(job_data_local_code)
+    }
+
+    # Now specify the @bucket_name - it should succeed.
+    job_data_local_code["@bucket_name"] = "/baz"
+    expected_local = "/baz/babel/temp-10"
+    actual_local_1 = BabelHelper.generate_output_location(job_data_local_code)
+    assert_equal(expected_local, actual_local_1)
+
+    # Specifying the BABEL_BUCKET_NAME environment variable should be OK.
+    job_data_local_code["@bucket_name"] = nil
+    ENV['BABEL_BUCKET_NAME'] = "/baz"
+    actual_local_2 = BabelHelper.generate_output_location(job_data_local_code)
+    assert_equal(expected_local, actual_local_2)
+
+    # Not putting the initial slash on the bucket name should be fine too.
+    ENV['BABEL_BUCKET_NAME'] = "baz"
+    actual_local_3 = BabelHelper.generate_output_location(job_data_local_code)
+    assert_equal(expected_local, actual_local_3)
+
+    # Finally, if we run a job and specify remote code, that should be used
+    # as the bucket.
+    job_data_remote_code = {"@code" => "/baz/boo/code.baz", "@is_remote" => true}
+    expected_remote = "/baz/babel/temp-10"
+
+    actual_remote = BabelHelper.generate_output_location(job_data_remote_code)
+    assert_equal(expected_remote, actual_remote)
+  end
+
+  def test_put_code
+    job_data = {"@code" => "/baz/boo/code.baz", "@bucket_name" => "/remote"}
+
+    neptune_params = {
+      :type => "input",
+      :local => "/baz/boo",
+      :remote => "/remote/babel/baz/boo",
+      :bucket_name => "/remote",
+      :code => "/baz/boo/code.baz"
+    }
+
+    kernel = flexmock(Kernel)
+    kernel.should_receive(:neptune).with(neptune_params)
+
+    expected = "/remote/babel/baz/boo/code.baz"
+    actual = BabelHelper.put_code(job_data)
+    assert_equal(expected, actual)
+  end
+
+  def test_put_inputs
+    # If we specify no inputs or no file inputs, we should get back exactly what
+    # we give it
+    job_data = {"@code" => "/baz/boo/code.baz", "@bucket_name" => "/remote"}
+    actual_1 = BabelHelper.put_inputs(job_data)
+    assert_equal(job_data, actual_1)
+
+    job_data["@argv"] = ["boo", "baz", "gbaz"]
+    actual_2 = BabelHelper.put_inputs(job_data)
+    assert_equal(job_data, actual_2)
+
+    # If we specify inputs on the file system, they should be uploaded and replaced
+    # with remote file locations
+    neptune_params = {
+      :type => "input",
+      :local => "/baz",
+      :remote => "/remote/babel/baz",
+      :bucket_name => "/remote",
+      :code => "/baz/boo/code.baz",
+      :argv => ["boo", "/baz", "gbaz"]
+    }
+
+    kernel = flexmock(Kernel)
+    kernel.should_receive(:neptune).with(neptune_params)
+
+    job_data["@argv"] = ["boo", "/baz", "gbaz"]
+    expected = job_data.dup
+    expected["@argv"] = ["boo", "/remote/babel/baz", "gbaz"]
+    actual_3 = BabelHelper.put_inputs(job_data.dup)
+    assert_equal(expected, actual_3)
+  end
+
+  def test_run_job
+    job_data = {
+      "@code" => "/baz/boo/code.baz",
+      "@argv" => ["boo", "/remote/babel/baz", "gbaz"]
+    }
+
+    neptune_params = {
+      :type => "babel",
+      :code => "/baz/boo/code.baz",
+      :argv => ["boo", "/remote/babel/baz", "gbaz"],
+      :run_local => true,
+      :engine => "executor-sqs"
+    }
+
+    result = { :result => :success }
+    kernel = flexmock(Kernel)
+    kernel.should_receive(:neptune).with(neptune_params).and_return(result)
+
+    expected = :success
+    actual = BabelHelper.run_job(job_data)[:result]
+    assert_equal(expected, actual)
+  end
+
+  def test_get_output
+    job_data = {
+      "@output" => "/baz/boo/code.baz"
+    }
+
+    neptune_params = {
+      :type => "output",
+      :output => "/baz/boo/code.baz"
+    }
+
+    result1 = { :output => DOES_NOT_EXIST }
+    result2 = { :output => "output goes here" }
+    kernel = flexmock(Kernel)
+    kernel.should_receive(:neptune).with(neptune_params).and_return(result1, result2)
+    kernel.should_receive(:sleep).and_return()
+
+    expected = "output goes here"
+    actual = BabelHelper.wait_and_get_output(job_data)
+    assert_equal(expected, actual)
+  end
+end

data/test/unit/test_common_functions.rb

@@ -7,100 +7,64 @@ require 'test/unit'
 
 SECRET = "hey-its-a-secret"
 
-module FakeCommonFunctions
-  def self.get_from_yaml(a, b, c)
-  end
 
-  def self.scp_file(a, b, c, d, e)
-  end
-end
+class TestCommonFunctions < Test::Unit::TestCase
+  def setup
+    @commonfunctions = flexmock(CommonFunctions)
+    @commonfunctions.should_receive(:scp_file).and_return()
+    @commonfunctions.should_receive(:shell).and_return()
 
-class FakeFile
-  @@exists_checks_done = 0
+    @file = flexmock(File)
+    @file.should_receive(:expand_path).and_return("")
 
-  def self.expand_path(path)
-    return path
-  end
+    @fileutils = flexmock(FileUtils)
+    @fileutils.should_receive(:rm_f).and_return()
 
-  def self.exists?(name)
-    if name.include?("OK") or name.include?("BAD-TAG") or name.include?("FAIL")
-      return true
-    elsif name.include?("retval")
-      # The first time around, tell the caller that the file didn't exist so
-      # that it sleeps. The next time around, tell it that the file does exist.
-      if @@exists_checks_done.zero?
-        @@exists_checks_done += 1
-        return false
-      else
-        return true
-      end
-    else
-      return false
-    end
-  end
+    @yaml = flexmock(YAML)
 
-  def self.open(name, mode=nil)
-    if name.include?("retval")
-      return "0\n"
-    else
-      return "1\n"
-    end
+    @yaml_info = { :secret => SECRET, :shadow => SECRET }
   end
-end
 
-module FakeFileUtils
-  def self.rm_f(name)
-    # Do nothing - faking out File means we don't have extra files to clean up
-  end
-end
+  def test_scp_to_shadow
+    @file.should_receive(:exists?).and_return(true)
+    @yaml.should_receive(:load_file).and_return(@yaml_info)
 
-module FakeKernel
-  def `(command)
-    # Do nothing - we don't need the side-effects from exec'ing a command
+    assert_nothing_raised(Exception) {
+      CommonFunctions.scp_to_shadow("", "", "", "")
+    }
   end
 
-  #def sleep(time)
-    # Do nothing - we don't actually need to sleep the current thread
-  #end
-end
+  def test_get_secret_key_file_exists
+    @file.should_receive(:exists?).and_return(true)
+    @yaml.should_receive(:load_file).and_return(@yaml_info)
 
-module FakeYAML
-  def self.load_file(filename)
-    if filename.include?("OK")
-      return { :secret => SECRET, :shadow => SECRET }
-    elsif filename.include?("BAD-TAG")
-      return {}
-    else
-      raise ArgumentError
-    end
+    assert_equal(SECRET, CommonFunctions.get_secret_key("", required=true))
   end
-end
 
-class TestCommonFunctions < Test::Unit::TestCase
-  def test_scp_to_shadow
-    assert_nothing_raised(Exception) {
-      CommonFunctions.scp_to_shadow("OK", "OK", "OK", "OK",
-        file=FakeFile,
-        get_from_yaml=FakeCommonFunctions.method(:get_from_yaml),
-        scp_file=FakeCommonFunctions.method(:scp_file))
+  def test_get_secret_key_malformed_yaml
+    assert_raise(BadConfigurationException) {
+      CommonFunctions.get_secret_key("", required=true)
     }
   end
 
-  def test_get_secret_key
-    assert_equal(SECRET, CommonFunctions.get_secret_key("OK", required=true,
-      FakeFile, FakeYAML))
+  def test_get_secret_key_wrong_tag
+    assert_raise(BadConfigurationException) {
+      CommonFunctions.get_secret_key("", required=true)
+    }
 
-    assert_raise(SystemExit) { CommonFunctions.get_secret_key("BAD-TAG",
-      required=true, FakeFile, FakeYAML) }
+    @file.should_receive(:exists?).and_return(true)
 
-    assert_raise(SystemExit) { CommonFunctions.get_secret_key("FAIL",
-      required=true, FakeFile, FakeYAML) }
-    assert_nil(CommonFunctions.get_secret_key("FAIL", required=false, FakeFile,
-      FakeYAML))
+    yaml_info_no_secret = { :shadow => SECRET }
+    @yaml.should_receive(:load_file).and_return(yaml_info_no_secret)
+
+    assert_nil(CommonFunctions.get_secret_key("", required=false))
+  end
 
-    assert_raise(SystemExit) {
-      CommonFunctions.get_secret_key("NOT-EXISTANT", required=true, FakeFile,
-        FakeYAML)
+  def test_get_secret_key_file_doesnt_exist
+    @file.should_receive(:exists).and_return(false)
+    
+    assert_raise(BadConfigurationException) {
+      CommonFunctions.get_secret_key("", required=true)
     }
   end
 end

data/test/unit/test_neptune.rb

@@ -5,182 +5,195 @@ require 'neptune'
 
 require 'test/unit'
 
-class FakeAppControllerClient
-  def initialize(a, b)
-  end
 
-  # Since all the methods we're faking take the same arguments and have
-  # the same semantics (return true or abort), just cover it all in one place.
-  def method_missing(id, *args, &block)
-    method_names = ["get_output", "get_acl", "put_input", "set_acl"] +
-      ["start_neptune_job"]
-    if method_names.include?(id.to_s)
-      return true
-    else
-      super
-    end
-  end
-end
+class TestNeptune < Test::Unit::TestCase
+  def setup
+    @commonfunctions = flexmock(CommonFunctions)
+    @commonfunctions.should_receive(:scp_to_shadow).and_return()
+    @commonfunctions.should_receive(:shell).and_return()
 
-class FakeFileNeptuneTest
-  def self.expand_path(path)
-    return path
-  end
+    @file = flexmock(File)
+    @file.should_receive(:expand_path).and_return("")
 
-  def self.exists?(file)
-    if file.include?("EXISTS")
-      return true
-    else
-      return false
-    end
-  end
-end
+    @fileutils = flexmock(FileUtils)
+    @fileutils.should_receive(:rm_f).and_return()
 
-module FakeKernel
-  def `(command)
-  end
-end
+    @kernel = flexmock(Kernel)
+    @kernel.should_receive(:puts).and_return()
 
-module FakeCommonFunctions
-  def self.scp_to_shadow(a, b, c, d=nil)
+    @yaml_info = {:load_balancer => "127.0.0.1",
+      :shadow => "127.0.0.1",
+      :secret => @secret,
+      :db_master => "node-1",
+      :table => "cassandra",
+      :instance_id => "i-FOOBARZ"}
+
+    @yaml = flexmock(YAML)
+    @yaml.should_receive(:load_file).and_return(@yaml_info)
   end
-end
 
-class TestNeptune < Test::Unit::TestCase
   def test_do_preprocessing
     # Try a job that needs preprocessing
     job_data_1 = {"@type" => "ssa", "@trajectories" => 10}
-    assert_nothing_raised(SystemExit) { do_preprocessing(job_data_1) }
+    assert_nothing_raised(BadConfigurationException) { 
+      NeptuneHelper.do_preprocessing(job_data_1, nil) 
+    }
 
     # Now try a job that doesn't need it
     job_data_2 = {"@type" => "input"}
-    assert_nothing_raised(SystemExit) { do_preprocessing(job_data_2) }
+    assert_nothing_raised(BadConfigurationException) {
+      NeptuneHelper.do_preprocessing(job_data_2, nil)
+    }
   end
 
   def test_preprocess_compile
   end
 
-  def test_preprocess_erlang
+  def test_preprocess_erlang_errors
+    @file.should_receive(:exists?).and_return(false)
+
     # Try a job where we didn't specify the code
     job_data_1 = {}
-    assert_raise(SystemExit) {
-      preprocess_erlang(job_data_1, FakeFileNeptuneTest, FakeCommonFunctions)
+    assert_raise(BadConfigurationException) {
+      NeptuneHelper.preprocess_erlang(job_data_1, nil)
     }
 
     # Try a job where the source doesn't exist
     job_data_2 = {"@code" => "NOT-EXISTANT"}
-    assert_raise(SystemExit) {
-      preprocess_erlang(job_data_2, FakeFileNeptuneTest, FakeCommonFunctions)
+    assert_raise(BadConfigurationException) {
+      NeptuneHelper.preprocess_erlang(job_data_2, nil)
     }
+  end
+
+  def test_preprocess_erlang_no_errors
+    @file.should_receive(:exists?).and_return(true)
 
     # Now try a job where the source does exist
     job_data_3 = {"@code" => "EXISTS"}
-    assert_nothing_raised(SystemExit) {
-      preprocess_erlang(job_data_3, FakeFileNeptuneTest, FakeCommonFunctions)
+    assert_nothing_raised(BadConfigurationException) {
+      NeptuneHelper.preprocess_erlang(job_data_3, nil)
     }
   end
 
   def test_preprocess_mpi
     # not specifying nodes to use or procs to use should throw an error
     job_data_1 = {}
-    assert_raise(SystemExit) { preprocess_mpi(job_data_1) }
+    assert_raise(BadConfigurationException) { 
+      NeptuneHelper.preprocess_mpi(job_data_1, nil)
+    }
 
     # not specifying procs to use should throw an error
     job_data_2 = {"@nodes_to_use" => 4}
-    assert_raise(SystemExit) { preprocess_mpi(job_data_2) }
+    assert_raise(BadConfigurationException) { 
+      NeptuneHelper.preprocess_mpi(job_data_2, nil)
+    }
 
     # specifying procs to use == nodes to use should not throw an error
     job_data_3 = {"@nodes_to_use" => 4, "@procs_to_use" => 4}
-    assert_equal(job_data_3, preprocess_mpi(job_data_3))
+    assert_equal(job_data_3, NeptuneHelper.preprocess_mpi(job_data_3, nil))
 
     # specifying procs to use < nodes to use should throw an error
     job_data_4 = {"@nodes_to_use" => 4, "@procs_to_use" => 1}
-    assert_raise(SystemExit) { preprocess_mpi(job_data_4) }
+    assert_raise(BadConfigurationException) { 
+      NeptuneHelper.preprocess_mpi(job_data_4, nil)
+    }
  
     # specifying an empty string for argv should be ok
     job_data_5 = {"@nodes_to_use" => 4, "@procs_to_use" => 4, "@argv" => ""}
-    assert_equal(job_data_5, preprocess_mpi(job_data_5))
+    assert_equal(job_data_5, NeptuneHelper.preprocess_mpi(job_data_5, nil))
 
     # specifying an empty array for argv should be ok
     job_data_6 = {"@nodes_to_use" => 4, "@procs_to_use" => 4, "@argv" => []}
     expected_job_data_6 = job_data_6.dup
     expected_job_data_6["@argv"] = ""
-    assert_equal(expected_job_data_6, preprocess_mpi(job_data_6))
+    assert_equal(expected_job_data_6, NeptuneHelper.preprocess_mpi(job_data_6, nil))
 
     # specifying something that's not a string or array for argv should throw
     # an error
     job_data_7 = {"@nodes_to_use" => 4, "@procs_to_use" => 4, "@argv" => 2}
-    assert_raise(SystemExit) { preprocess_mpi(job_data_7) }
+    assert_raise(BadConfigurationException) { 
+      NeptuneHelper.preprocess_mpi(job_data_7, nil)
+    }
 
     # specifying a non-empty string for argv should be ok
     job_data_8 = {"@nodes_to_use" => 4, "@procs_to_use" => 4, "@argv" => "--file coo"}
-    assert_equal(job_data_8, preprocess_mpi(job_data_8))
+    assert_equal(job_data_8, NeptuneHelper.preprocess_mpi(job_data_8, nil))
 
     # specifying a non-empty array for argv should be ok
     job_data_9 = {"@nodes_to_use" => 4, "@procs_to_use" => 4, "@argv" => ["--file", "coo"]}
     expected_job_data_9 = job_data_9.dup
     expected_job_data_9["@argv"] = "--file coo"
-    assert_equal(expected_job_data_9, preprocess_mpi(job_data_9))
+    assert_equal(expected_job_data_9, NeptuneHelper.preprocess_mpi(job_data_9, nil))
   end
 
   def test_preprocess_ssa
     job_data_1 = {}
-    assert_raise(SystemExit) { preprocess_ssa(job_data_1) }
+    assert_raise(BadConfigurationException) {
+      NeptuneHelper.preprocess_ssa(job_data_1, nil) 
+    }
 
     job_data_2 = {"@trajectories" => 10}
-    assert_equal(job_data_2, preprocess_ssa(job_data_2))
+    assert_equal(job_data_2, NeptuneHelper.preprocess_ssa(job_data_2, nil))
 
     job_data_3 = {"@simulations" => 10}
     expected_job_data_3 = {"@trajectories" => 10}
-    assert_equal(expected_job_data_3, preprocess_ssa(job_data_3))
+    assert_equal(expected_job_data_3, NeptuneHelper.preprocess_ssa(job_data_3, nil))
 
     job_data_4 = {"@trajectories" => 10, "@simulations" => 10}
-    assert_raise(SystemExit) { preprocess_ssa(job_data_4) }
+    assert_raise(BadConfigurationException) { NeptuneHelper.preprocess_ssa(job_data_4, nil) }
   end
 
   def test_get_job_data
     params_1 = {:type => :mpi}
-    assert_raise(SystemExit) { get_job_data(params_1) }
+    assert_raise(BadConfigurationException) {
+      NeptuneHelper.get_job_data(params_1)
+    }
 
     params_2 = {:type => :mpi, :output => "boo"}
-    assert_raise(SystemExit) { get_job_data(params_2) }
+    assert_raise(BadConfigurationException) { 
+      NeptuneHelper.get_job_data(params_2)
+    }
 
     [:mpi, :upc, :x10].each { |type|
       params_3 = {:type => type, :output => "/boo"}
       expected_job_data_3 = {"@type" => "mpi", "@output" => "/boo",
         "@keyname" => "appscale"}
-      assert_equal(expected_job_data_3, get_job_data(params_3))
+      assert_equal(expected_job_data_3, NeptuneHelper.get_job_data(params_3))
     }
 
     params_4 = {:type => "input"}
     expected_job_data_4 = {"@type" => "input", "@keyname" => "appscale"}
-    assert_equal(expected_job_data_4, get_job_data(params_4))
+    assert_equal(expected_job_data_4, NeptuneHelper.get_job_data(params_4))
 
     params_5 = {:type => "input", :keyname => "boo"}
     expected_job_data_5 = {"@type" => "input", "@keyname" => "boo"}
-    assert_equal(expected_job_data_5, get_job_data(params_5))
+    assert_equal(expected_job_data_5, NeptuneHelper.get_job_data(params_5))
 
     params_6 = {:type => :mpi, :output => "/boo",
       :nodes_to_use => {"cloud1" => 1, "cloud2" => 1}}
     expected_job_data_6 = {"@type" => "mpi", "@output" => "/boo",
       "@keyname" => "appscale", "@nodes_to_use" => ["cloud1", 1, "cloud2", 1]}
-    assert_equal(expected_job_data_6, get_job_data(params_6))
+    assert_equal(expected_job_data_6, NeptuneHelper.get_job_data(params_6))
   end
 
   def test_validate_storage_params
     job_data_1 = {}
     expected_job_data_1 = {"@storage" => "appdb"}
-    assert_equal(expected_job_data_1, validate_storage_params(job_data_1))
+    assert_equal(expected_job_data_1, NeptuneHelper.validate_storage_params(job_data_1))
 
     job_data_2 = {"@storage" => "a bad value goes here"}
-    assert_raise(SystemExit) { validate_storage_params(job_data_2) }
+    assert_raise(BadConfigurationException) { 
+      NeptuneHelper.validate_storage_params(job_data_2)
+    }
 
     job_data_3 = {"@storage" => "s3"}
-    assert_raise(SystemExit) { validate_storage_params(job_data_3) }
+    assert_raise(BadConfigurationException) {
+      NeptuneHelper.validate_storage_params(job_data_3)
+    }
 
     job_data_4 = {"@storage" => "s3", "@EC2_ACCESS_KEY" => "a",
       "@EC2_SECRET_KEY" => "b", "@S3_URL" => "c"}
-    assert_equal(job_data_4, validate_storage_params(job_data_4))
+    assert_equal(job_data_4, NeptuneHelper.validate_storage_params(job_data_4))
 
     ENV['EC2_ACCESS_KEY'] = "a"
     ENV['EC2_SECRET_KEY'] = "b"
@@ -190,7 +203,7 @@ class TestNeptune < Test::Unit::TestCase
       job_data_5 = {"@storage" => storage}
       expected_job_data_5 = {"@storage" => "s3", "@EC2_ACCESS_KEY" => "a",
         "@EC2_SECRET_KEY" => "b", "@S3_URL" => "c"}
-      assert_equal(expected_job_data_5, validate_storage_params(job_data_5))
+      assert_equal(expected_job_data_5, NeptuneHelper.validate_storage_params(job_data_5))
     }
   end
 
@@ -203,25 +216,40 @@ class TestNeptune < Test::Unit::TestCase
   def test_compile_code
   end
 
-  def test_run_job
+  def test_run_job_with_errors
     ssh_args = "boo!"
     shadow_ip = "localhost?"
     secret = "abcdefg"
 
     job_data_1 = {"@type" => "input"}
-    assert_raises (SystemExit) { 
-      run_job(job_data_1, ssh_args, shadow_ip, secret,
-        FakeAppControllerClient, FakeFileNeptuneTest)
+    assert_raises (BadConfigurationException) { 
+      NeptuneHelper.run_job(job_data_1, ssh_args, shadow_ip, secret)
+    }
+
+    @file.should_receive(:exists?).and_return(false)
+    flexmock(AppControllerClient).new_instances { |instance|
+      instance.should_receive(:put_input).and_return(true)
     }
 
     job_data_1 = {"@type" => "input", "@local" => "NON-EXISTANT"}
-    actual_1 = run_job(job_data_1, ssh_args, shadow_ip, secret,
-      FakeAppControllerClient, FakeFileNeptuneTest)
+    actual_1 = NeptuneHelper.run_job(job_data_1, ssh_args, shadow_ip, secret)
     assert_equal(:failure, actual_1[:result])
+  end
+
+  def test_run_job_no_errors
+    ssh_args = "boo!"
+    shadow_ip = "localhost?"
+    secret = "abcdefg"
+
+    flexmock(AppControllerClient).new_instances { |instance|
+      instance.should_receive(:put_input).and_return(true)
+    }
+
+
+    @file.should_receive(:exists?).and_return(true)
 
     job_data_2 = {"@type" => "input", "@local" => "EXISTS"}
-    actual_2 = run_job(job_data_2, ssh_args, shadow_ip, secret,
-      FakeAppControllerClient, FakeFileNeptuneTest)
+    actual_2 = NeptuneHelper.run_job(job_data_2, ssh_args, shadow_ip, secret)
     assert_equal(:success, actual_2[:result])
 
     # try an output job
@@ -234,4 +262,68 @@ class TestNeptune < Test::Unit::TestCase
 
     # try a compute job
   end
+
+  def test_babel_job_validation
+    input = "/boo/input.txt"
+    output = "/boo/baz.txt"
+    code = "/boo/code.go"
+    engine = "appscale-sqs"
+    all_engines = [engine]
+
+    @commonfunctions.should_receive(:get_from_yaml).and_return("127.0.0.1")
+    @commonfunctions.should_receive(:get_secret_key).and_return("secret")
+
+    flexmock(AppControllerClient).new_instances { |instance|
+      instance.should_receive(:start_neptune_job).and_return("babel job is now running")
+      instance.should_receive(:get_supported_babel_engines).and_return(all_engines)
+      instance.should_receive(:does_file_exist?).and_return(true, false, true)
+    }
+
+    # test cases where we don't give all the correct params
+    params1 = {:type => :babel}
+    assert_raises(BadConfigurationException) { neptune(params1) }
+
+    params2 = {:type => :babel, :output => output}
+    assert_raises(BadConfigurationException) { neptune(params2) }
+
+    params3 = {:type => :babel, :output => output, :code => code}
+    assert_raises(BadConfigurationException) { neptune(params3) }
+
+    # test a case where we do give all the correct params
+
+    params = {:type => :babel,
+              :output => output,
+              :code => code,
+              :engine => engine,
+              :argv => [input]}
+    result = neptune(params)
+    assert_equal(:success, result[:result])
+  end
+
+  def test_babel_where_remote_files_dont_exist
+    output = "/boo/baz.txt"
+    code = "/boo/code.go"
+    engine = "appscale-sqs"
+    all_engines = [engine]
+
+    @commonfunctions.should_receive(:get_from_yaml).and_return("127.0.0.1")
+    @commonfunctions.should_receive(:get_secret_key).and_return("secret")
+
+    flexmock(AppControllerClient).new_instances { |instance|
+      instance.should_receive(:start_neptune_job).and_return("babel job is now running")
+      instance.should_receive(:get_supported_babel_engines).and_return(all_engines)
+      instance.should_receive(:does_file_exist?).and_return(false)
+    }
+
+    params = {:type => :babel,
+      :output => output,
+      :code => code,
+      :engine => engine}
+    assert_raises(FileNotFoundException) { neptune(params) }
+
+  end
+
+  def test_babel_engine_validation
+    # TODO(cgb): test a case where we name an unsupported engine - it should fail
+  end
 end