Home | History | Annotate | Download | only in deployment 
      1 #!/usr/bin/python
      2 
      3 import contextlib
      4 import sys
      5 import unittest
      6 
      7 import common
      8 from autotest_lib.site_utils.deployment import cmdparse
      9 
     10 
     11 @contextlib.contextmanager
     12 def _suppress_error_output():
     13     stderr_save = sys.stderr
     14     try:
     15         with open('/dev/null', 'w') as sys.stderr:
     16             yield
     17     finally:
     18         sys.stderr = stderr_save
     19 
     20 
     21 class BooleanArgumentTestCase(unittest.TestCase):
     22     """Tests for parsing and adding boolean arguments."""
     23 
     24     def _make_parser(self, option, default):
     25         parser = cmdparse._ArgumentParser()
     26         parser.add_boolean_argument(option, default)
     27         return parser
     28 
     29     def test_conflicting_options_raises_error_with_false_default(self):
     30         """Test handling when both the true and false options are used."""
     31         # By default, when there's a command line syntax error,
     32         # `argparse.ArgumentParser` prints messages on sys.stderr and
     33         # then calls `sys.exit()`.  So, take the time to catch/suppress
     34         # those behaviors.
     35         with _suppress_error_output():
     36             parser = self._make_parser('option', False)
     37             with self.assertRaises(SystemExit):
     38                 parser.parse_args(['--option', '--nooption'])
     39             with self.assertRaises(SystemExit):
     40                 parser.parse_args(['--nooption', '--option'])
     41 
     42     def test_conflicting_options_raises_error_with_true_default(self):
     43         """Test handling when both the true and false options are used."""
     44         # By default, when there's a command line syntax error,
     45         # `argparse.ArgumentParser` prints messages on sys.stderr and
     46         # then calls `sys.exit()`.  So, take the time to catch/suppress
     47         # those behaviors.
     48         with _suppress_error_output():
     49             parser = self._make_parser('option', True)
     50             with self.assertRaises(SystemExit):
     51                 parser.parse_args(['--option', '--nooption'])
     52             with self.assertRaises(SystemExit):
     53                 parser.parse_args(['--nooption', '--option'])
     54 
     55     def test_no_option_wth_false_default(self):
     56         """Test option handling when no option is provided."""
     57         parser = self._make_parser('option', False)
     58         arguments = parser.parse_args([])
     59         self.assertFalse(arguments.option)
     60 
     61     def test_no_option_wth_true_default(self):
     62         """Test option handling when no option is provided."""
     63         parser = self._make_parser('option', True)
     64         arguments = parser.parse_args([])
     65         self.assertTrue(arguments.option)
     66 
     67     def test_true_option_returns_true_with_false_default(self):
     68         """Test option handling when only the true option is provided."""
     69         parser = self._make_parser('option', False)
     70         arguments = parser.parse_args(['--option'])
     71         self.assertTrue(arguments.option)
     72 
     73     def test_true_option_returns_true_with_true_default(self):
     74         """Test option handling when only the true option is provided."""
     75         parser = self._make_parser('option', True)
     76         arguments = parser.parse_args(['--option'])
     77         self.assertTrue(arguments.option)
     78 
     79     def test_false_option_returns_false_with_false_default(self):
     80         """Test option handling when only the false option is provided."""
     81         parser = self._make_parser('option', False)
     82         arguments = parser.parse_args(['--nooption'])
     83         self.assertFalse(arguments.option)
     84 
     85     def test_false_option_returns_false_with_true_default(self):
     86         """Test option handling when only the false option is provided."""
     87         parser = self._make_parser('option', True)
     88         arguments = parser.parse_args(['--nooption'])
     89         self.assertFalse(arguments.option)
     90 
     91 
     92 def _test_parse_command(argv):
     93     return cmdparse.parse_command(['command'] + argv)
     94 
     95 
     96 class _CommandParserTestCase(unittest.TestCase):
     97     _ALL_SUBCOMMANDS = ['servo', 'firmware', 'test-image', 'repair']
     98 
     99     def _check_common_defaults(self, arguments):
    100         self.assertIsNone(arguments.web)
    101         self.assertIsNone(arguments.logdir)
    102         self.assertFalse(arguments.dry_run)
    103         self.assertIsNone(arguments.board)
    104         self.assertIsNone(arguments.build)
    105         self.assertIsNone(arguments.hostname_file)
    106         self.assertEquals(arguments.hostnames, [])
    107 
    108     def test_web_option(self):
    109         """Test handling of `--web`, both long and short forms."""
    110         opt_arg = 'servername'
    111         for option in ['-w', '--web']:
    112             argv = [option, opt_arg]
    113             for subcmd in self._ALL_SUBCOMMANDS:
    114                 arguments = _test_parse_command([subcmd] + argv)
    115                 self.assertEquals(arguments.web, opt_arg)
    116 
    117     def test_logdir_option(self):
    118         """Test handling of `--dir`, both long and short forms."""
    119         opt_arg = 'dirname'
    120         for option in ['-d', '--dir']:
    121             argv = [option, opt_arg]
    122             for subcmd in self._ALL_SUBCOMMANDS:
    123                 arguments = _test_parse_command([subcmd] + argv)
    124                 self.assertEquals(arguments.logdir, opt_arg)
    125 
    126     def test_dry_run_option(self):
    127         """Test handling of `--dry-run`, both long and short forms."""
    128         # assert False
    129         for option in ['-n', '--dry-run']:
    130             argv = [option]
    131             for subcmd in self._ALL_SUBCOMMANDS:
    132                 arguments = _test_parse_command([subcmd] + argv)
    133                 self.assertTrue(arguments.dry_run)
    134 
    135     def test_build_option(self):
    136         """Test handling of `--build`, both long and short forms."""
    137         opt_arg = 'R66-10447.0.0'
    138         for option in ['-i', '--build']:
    139             argv = [option, opt_arg]
    140             for subcmd in self._ALL_SUBCOMMANDS:
    141                 arguments = _test_parse_command([subcmd] + argv)
    142                 self.assertEquals(arguments.build, opt_arg)
    143 
    144     def test_hostname_file_option(self):
    145         """Test handling of `--hostname_file`, both long and short forms."""
    146         opt_arg = 'hostfiles.csv'
    147         for option in ['-f', '--hostname_file']:
    148             argv = [option, opt_arg]
    149             for subcmd in self._ALL_SUBCOMMANDS:
    150                 arguments = _test_parse_command([subcmd] + argv)
    151                 self.assertEquals(arguments.hostname_file, opt_arg)
    152 
    153     def test_upload_option(self):
    154         """Test handling of `--upload`, both long and short forms."""
    155         argv = ['--upload']
    156         for subcmd in self._ALL_SUBCOMMANDS:
    157             arguments = _test_parse_command([subcmd] + argv)
    158             self.assertTrue(arguments.upload)
    159 
    160     def test_noupload_option(self):
    161         """Test handling of `--noupload`, both long and short forms."""
    162         argv = ['--noupload']
    163         for subcmd in self._ALL_SUBCOMMANDS:
    164             arguments = _test_parse_command([subcmd] + argv)
    165             self.assertFalse(arguments.upload)
    166 
    167     def test_board_option(self):
    168         """Test the `--board` option for subcommands."""
    169         opt_arg = 'board'
    170         for option in ['-b', '--board']:
    171             for subcmd in self._ALL_SUBCOMMANDS:
    172                 arguments = _test_parse_command([subcmd, option, opt_arg])
    173                 self.assertEquals(arguments.board, opt_arg)
    174 
    175     def test_model_option(self):
    176         """Test the `--model` option for subcommands."""
    177         opt_arg = 'model'
    178         for option in ['-m', '--model']:
    179             for subcmd in self._ALL_SUBCOMMANDS:
    180                 arguments = _test_parse_command([subcmd, option, opt_arg])
    181                 self.assertEquals(arguments.model, opt_arg)
    182 
    183     def test_hostname_arguments(self):
    184         """Test hostname arguments for subcommands."""
    185         argument = 'hostname'
    186         for subcmd in self._ALL_SUBCOMMANDS:
    187             arguments = _test_parse_command([subcmd, argument])
    188             self.assertEquals(arguments.hostnames, [argument])
    189 
    190     def test_servo_defaults(self):
    191         """Test argument defaults for `deploy servo`."""
    192         arguments = _test_parse_command(['servo'])
    193         self._check_common_defaults(arguments)
    194         self.assertTrue(arguments.stageusb)
    195         self.assertFalse(arguments.install_firmware)
    196         self.assertFalse(arguments.install_test_image)
    197 
    198     def test_firmware_defaults(self):
    199         """Test argument defaults for `deploy firmware`."""
    200         arguments = _test_parse_command(['firmware'])
    201         self._check_common_defaults(arguments)
    202         self.assertFalse(arguments.stageusb)
    203         self.assertTrue(arguments.install_firmware)
    204         self.assertTrue(arguments.install_test_image)
    205 
    206     def test_test_image_defaults(self):
    207         """Test argument defaults for `deploy test-image`."""
    208         arguments = _test_parse_command(['test-image'])
    209         self._check_common_defaults(arguments)
    210         self.assertFalse(arguments.stageusb)
    211         self.assertFalse(arguments.install_firmware)
    212         self.assertTrue(arguments.install_test_image)
    213 
    214     def test_repair_defaults(self):
    215         """Test argument defaults for `deploy repair`."""
    216         arguments = _test_parse_command(['repair'])
    217         self._check_common_defaults(arguments)
    218         self.assertFalse(arguments.stageusb)
    219         self.assertFalse(arguments.install_firmware)
    220         self.assertTrue(arguments.install_test_image)
    221 
    222 
    223 if __name__ == '__main__':
    224     unittest.main()
    225