| #!/usr/bin/python2 |
| # |
| # Copyright 2019 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import unittest |
| |
| import common |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib import utils |
| from autotest_lib.client.common_lib.cros import cros_config |
| |
| # Lots of command-line mocking in this file. |
| # Mock cros_config results are based on the path and property provided. |
| # (Remember, cros_config's syntax is `cros_config path property`.) |
| # The path determines whether cros_config fails or succeeds. |
| # The property determines whether there is a fallback command, and if so, |
| # whether the fallback fails or succeeds. |
| |
| SUCCEEDS = 0 |
| FAILS = 1 |
| DOES_NOT_EXIST = 2 |
| |
| # cros_config path determines the mock behavior of cros_config. |
| CC_PATHS = {SUCCEEDS: '/success', FAILS: '/error'} |
| |
| # cros_config property determines the mock behavior of the fallback command. |
| CC_PROPERTIES = { |
| SUCCEEDS: 'fallback_succeeds', |
| FAILS: 'fallback_fails', |
| DOES_NOT_EXIST: 'no_fallback' |
| } |
| |
| CROS_CONFIG_SUCCESS_RESPONSE = 'cros_config succeeded' |
| CROS_CONFIG_FALLBACK_RESPONSE = 'fallback succeeded' |
| |
| |
| def get_cros_config_args(cros_config_result, fallback_result): |
| """Build cros_config_args based on the desired outcome.""" |
| cros_config_path = CC_PATHS[cros_config_result] |
| cros_config_property = CC_PROPERTIES[fallback_result] |
| return '%s %s' % (cros_config_path, cros_config_property) |
| |
| |
| class _CrosConfigBaseTestCase(unittest.TestCase): |
| """Base class which sets up mock fallback commands""" |
| |
| def setUp(self): |
| """Add mock fallback command(s) to cros_config.FALLBACKS""" |
| for path in CC_PATHS.values(): |
| pass_args = '%s %s' % (path, CC_PROPERTIES[SUCCEEDS]) |
| fail_args = '%s %s' % (path, CC_PROPERTIES[FAILS]) |
| cros_config.FALLBACKS[pass_args] = \ |
| 'echo %s' % CROS_CONFIG_FALLBACK_RESPONSE |
| cros_config.FALLBACKS[fail_args] = 'this command does nothing' |
| |
| def tearDown(self): |
| """Remove mock fallback command(s) from cros_config.FALLBACKS""" |
| for path in CC_PATHS.values(): |
| pass_args = '%s %s' % (path, CC_PROPERTIES[SUCCEEDS]) |
| fail_args = '%s %s' % (path, CC_PROPERTIES[FAILS]) |
| del cros_config.FALLBACKS[pass_args] |
| del cros_config.FALLBACKS[fail_args] |
| |
| |
| class GetFallbackTestCase(_CrosConfigBaseTestCase): |
| """Verify cros_config.get_fallback""" |
| |
| def runTest(self): |
| """Check handling for commands with and without fallbacks""" |
| self.assertFalse( |
| cros_config.get_fallback( |
| '%s %s' % (CC_PATHS[SUCCEEDS], |
| CC_PROPERTIES[DOES_NOT_EXIST]))) |
| self.assertEqual( |
| cros_config.get_fallback('%s %s' % (CC_PATHS[SUCCEEDS], |
| CC_PROPERTIES[SUCCEEDS])), |
| 'echo %s' % CROS_CONFIG_FALLBACK_RESPONSE) |
| |
| |
| def _mock_cmd_runner(cmd, **kwargs): |
| """ |
| Mock running a DUT command, returning a CmdResult. |
| |
| We handle a few mock functions here: |
| * cros_config $path $property: $path determines error or success. |
| $property is not used here. |
| * echo $text: Returns $text with a trailing newline. |
| |
| Additionally, if the kwarg `ignore_status` is passed in as True, |
| then when cros_config would raise an error, it instead returns a |
| CmdResult with an exit_status of 1. |
| |
| @param cmd: A command, as would be run on the DUT |
| @param **kwargs: Kwargs that might be passed into, say, utils.run() |
| @return: A mock response from the DUT |
| |
| @type cmd: string |
| @rtype: client.common_lib.utils.CmdResult |
| |
| @raise error.CmdError if cros_config should raise an exception. |
| @raise NotImplementedError if cros_config has an unexpected path |
| |
| """ |
| result = utils.CmdResult(cmd) |
| if cmd.startswith('cros_config '): |
| _, path, _ = cmd.split() |
| if path == CC_PATHS[SUCCEEDS]: |
| result.stdout = CROS_CONFIG_SUCCESS_RESPONSE |
| elif path == CC_PATHS[FAILS]: |
| result.exit_status = 1 |
| if not kwargs.get('ignore_status'): |
| raise error.CmdError(cmd, result) |
| else: |
| raise NotImplementedError('Bad cros_config path: %s' % path) |
| elif cmd.startswith('echo '): |
| result.stdout = cmd.lstrip('echo ') + '\n' |
| else: |
| result.exit_status = 2 |
| if not kwargs.get('ignore_status'): |
| raise error.CmdError(cmd, result) |
| return result |
| |
| |
| class CallCrosConfigWithFallbackTestCase(_CrosConfigBaseTestCase): |
| """Verify cros_config.call_cros_config_with_fallback""" |
| |
| def run_cc_w_fallback(self, cros_config_result, fallback_result, |
| ignore_status=False): |
| """ |
| Helper function to call |
| cros_config.call_cros_config_with_fallback() |
| |
| """ |
| cc_args = get_cros_config_args(cros_config_result, fallback_result) |
| if ignore_status: |
| return cros_config.call_cros_config_with_fallback( |
| cc_args, _mock_cmd_runner, ignore_status=True) |
| else: |
| return cros_config.call_cros_config_with_fallback( |
| cc_args, _mock_cmd_runner) |
| |
| def test_cros_config_success(self): |
| """ |
| Verify that if cros_config is defined, we get the cros_config |
| result, regardless of whether there is a fallback command. |
| |
| """ |
| for fallback_status in (SUCCEEDS, FAILS, DOES_NOT_EXIST): |
| for ignore_status in (True, False): |
| output = self.run_cc_w_fallback(SUCCEEDS, fallback_status, |
| ignore_status) |
| self.assertEqual(output.stdout, CROS_CONFIG_SUCCESS_RESPONSE) |
| self.assertFalse(output.exit_status) |
| |
| def test_fallback_success(self): |
| """ |
| Verify that if cros_config is not defined but a fallback is, |
| we get the fallback result. |
| |
| """ |
| for ignore_status in (True, False): |
| output = self.run_cc_w_fallback(FAILS, SUCCEEDS, ignore_status) |
| self.assertEqual(output.stdout, CROS_CONFIG_FALLBACK_RESPONSE) |
| self.assertFalse(output.exit_status) |
| |
| def test_fallback_fails(self): |
| """ |
| Verify that if both cros_config and the fallback fail, a |
| CmdError is raised. |
| |
| """ |
| with self.assertRaises(error.CmdError): |
| self.run_cc_w_fallback(FAILS, FAILS) |
| |
| def test_fallback_dne(self): |
| """ |
| Verify that if cros_config fails and the fallback does not |
| exist, a CmdError is raised. |
| |
| """ |
| with self.assertRaises(error.CmdError): |
| self.run_cc_w_fallback(FAILS, DOES_NOT_EXIST) |
| |
| def test_fallback_fails_ignore_status(self): |
| """ |
| Verify that if both cros_config and the fallback fail, and the |
| ignore_status kwarg is passed in, we get a CmdResult with a |
| non-zero exit status. |
| |
| """ |
| output = self.run_cc_w_fallback(FAILS, FAILS, True) |
| self.assertTrue(output.exit_status) |
| |
| def test_fallback_dne_ignore_status(self): |
| """ |
| Verify that if cros_config fails and the fallback does not |
| exist, and the ignore_status kwarg is passed in, we get a |
| CmdResult with a non-zero exit status. |
| |
| """ |
| output = self.run_cc_w_fallback(FAILS, DOES_NOT_EXIST, True) |
| self.assertTrue(output.exit_status) |
| |
| |
| class CallCrosConfigGetOutputTestCase(_CrosConfigBaseTestCase): |
| """ |
| Verify cros_config.call_cros_config_get_output. |
| Basically the same as CallCrosConfigWithFallbackTestCase, except |
| that the expected result is a string instead of a CmdResult, and |
| it shouldn't raise exceptions. |
| |
| """ |
| |
| def run_cc_get_output(self, cros_config_result, fallback_result, |
| ignore_status=False): |
| """ |
| Helper function to call |
| cros_config.call_cros_config_get_output() |
| |
| """ |
| cc_args = get_cros_config_args(cros_config_result, fallback_result) |
| if ignore_status: |
| return cros_config.call_cros_config_get_output( |
| cc_args, _mock_cmd_runner, ignore_status=True) |
| else: |
| return cros_config.call_cros_config_get_output( |
| cc_args, _mock_cmd_runner) |
| |
| def test_cros_config_success(self): |
| """ |
| Verify that if cros_config is defined, we get the cros_config |
| result, regardless of whether there is a fallback command. |
| |
| """ |
| for fallback_status in (SUCCEEDS, FAILS, DOES_NOT_EXIST): |
| output = self.run_cc_get_output(SUCCEEDS, fallback_status) |
| self.assertEqual(output, CROS_CONFIG_SUCCESS_RESPONSE) |
| |
| def test_fallback_success(self): |
| """ |
| Verify that if cros_config is not defined but a fallback is, |
| we get the fallback result. |
| |
| """ |
| output = self.run_cc_get_output(FAILS, SUCCEEDS) |
| self.assertEqual(output, CROS_CONFIG_FALLBACK_RESPONSE) |
| |
| def test_fallback_fails(self): |
| """ |
| Verify that if both cros_config and the fallback fail, we get |
| a falsey value. |
| |
| """ |
| output = self.run_cc_get_output(FAILS, FAILS) |
| self.assertFalse(output) |
| |
| def test_fallback_dne(self): |
| """ |
| Verify that if cros_config fails and the fallback does not |
| exist, we get a falsey value. |
| |
| """ |
| output = self.run_cc_get_output(FAILS, DOES_NOT_EXIST) |
| self.assertFalse(output) |
| |
| def test_fallback_fails_ignore_status(self): |
| """ |
| Verify that if both cros_config and the fallback fail, and the |
| ignore_status kwarg is passed in, we get a falsey value. |
| |
| """ |
| output = self.run_cc_get_output(FAILS, FAILS, True) |
| self.assertFalse(output) |
| |
| def test_fallback_dne_ignore_status(self): |
| """ |
| Verify that if cros_config fails and the fallback does not |
| exist, and the ignore_status kwarg is passed in, we get a |
| falsey value. |
| |
| """ |
| output = self.run_cc_get_output(FAILS, DOES_NOT_EXIST, True) |
| self.assertFalse(output) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
