Merge remote branch 'cros/upstream' into master.

client/bin/job_unittest.py

 #!/usr/bin/python
 
 import logging, os, shutil, sys, time, StringIO
 import common
 
 from autotest_lib.client.bin import job, boottool, config, sysinfo, harness
 from autotest_lib.client.bin import test, xen, kernel, utils
 from autotest_lib.client.common_lib import packages, error, log
 from autotest_lib.client.common_lib import logging_manager, logging_config
 from autotest_lib.client.common_lib import base_job_unittest
@@ skipping 64 matching lines @@
                                          stub_sysinfo())
         class stub_harness:
             run_start = lambda self: None
         self.god.stub_function_to_return(job.harness, 'select', stub_harness())
         self.god.stub_function_to_return(job.boottool, 'boottool', object())
         class options:
             tag = ''
             verbose = False
             cont = False
             harness = 'stub'
+            harness_args = None
             hostname = None
             user = None
             log = False
             args = ''
             tap_report = None
         self.god.stub_function_to_return(job.utils, 'drop_caches', None)
 
         self.job._job_state = base_job_unittest.stub_job_state
         self.job.__init__('/control', options)
 
@@ skipping 79 matching lines @@
         tmpdir = os.path.join(self.autodir, 'tmp')
         if not cont:
             job.base_client_job._cleanup_debugdir_files.expect_call()
             job.base_client_job._cleanup_results_dir.expect_call()
 
         self.job._load_state.expect_call()
 
         my_harness = self.god.create_mock_class(harness.harness,
                                                 'my_harness')
         harness.select.expect_call(None,
-                                   self.job).and_return(my_harness)
+                                   self.job,
+                                   None).and_return(my_harness)
 
         return resultdir, my_harness
 
 
     def _setup_post_record_init(self, cont, resultdir, my_harness):
         # now some specific stubs
         self.god.stub_function(self.job, 'config_get')
         self.god.stub_function(self.job, 'config_set')
         self.god.stub_function(self.job, 'record')
 
@@ skipping 35 matching lines @@
 
         # record
         resultdir, my_harness = self._setup_pre_record_init(cont)
         self._setup_post_record_init(cont, resultdir, my_harness)
 
         # finish constructor
         options = dummy()
         options.tag = self.jobtag
         options.cont = cont
         options.harness = None
+        options.harness_args = None
         options.log = False
         options.verbose = False
         options.hostname = 'localhost'
         options.user = 'my_user'
         options.args = ''
         options.tap_report = None
         self.job.__init__(self.control, options,
                           extra_copy_cmdline=['more-blah'])
 
         # check
@@ skipping 20 matching lines @@
 
     def test_constructor_post_record_failure(self):
         """
         Test post record initialization failure.
         """
         self.job = job.base_client_job.__new__(job.base_client_job)
         options = dummy()
         options.tag = self.jobtag
         options.cont = False
         options.harness = None
+        options.harness_args = None
         options.log = False
         options.verbose = False
         options.hostname = 'localhost'
         options.user = 'my_user'
         options.args = ''
         options.tap_report = None
         error = Exception('fail')
 
         self.god.stub_function(self.job, '_post_record_init')
         self.god.stub_function(self.job, 'record')
@@ skipping 25 matching lines @@
         control_file = "blah"
         self.job.control_set(control_file)
         self.assertEquals(self.job.control_get(), os.path.abspath(control_file))
 
 
     def test_harness_select(self):
         self.construct_job(True)
 
         # record
         which = "which"
-        harness.select.expect_call(which, self.job).and_return(None)
+        harness_args = ''
+        harness.select.expect_call(which, self.job, 
+                                   harness_args).and_return(None)
 
         # run and test
-        self.job.harness_select(which)
+        self.job.harness_select(which, harness_args)
         self.god.check_playback()
 
 
     def test_config_set(self):
         self.construct_job(True)
 
         # unstub config_set
         self.god.unstub(self.job, 'config_set')
         # record
         name = "foo"
@@ skipping 363 matching lines @@
                     "a='b c d' no=argh":
                     ["a='b c d'", "no=argh"]}
         for t in test_set:
             parsed_args = job.base_client_job._parse_args(t)
             expected_args = test_set[t]
             self.assertEqual(parsed_args, expected_args)
 
 
 if __name__ == "__main__":
     unittest.main()