• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/python2
2
3import contextlib
4import sys
5import unittest
6
7import common
8from autotest_lib.site_utils.deployment import cmdparse
9
10
11@contextlib.contextmanager
12def _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
21class 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
92def _test_parse_command(argv):
93    return cmdparse.parse_command(['command'] + argv)
94
95
96class _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        self.assertFalse(arguments.reinstall_test_image)
198
199    def test_firmware_defaults(self):
200        """Test argument defaults for `deploy firmware`."""
201        arguments = _test_parse_command(['firmware'])
202        self._check_common_defaults(arguments)
203        self.assertFalse(arguments.stageusb)
204        self.assertFalse(arguments.reinstall_test_image)
205        self.assertTrue(arguments.install_firmware)
206        self.assertTrue(arguments.install_test_image)
207
208    def test_test_image_defaults(self):
209        """Test argument defaults for `deploy test-image`."""
210        arguments = _test_parse_command(['test-image'])
211        self._check_common_defaults(arguments)
212        self.assertFalse(arguments.stageusb)
213        self.assertFalse(arguments.install_firmware)
214        self.assertFalse(arguments.reinstall_test_image)
215        self.assertTrue(arguments.install_test_image)
216
217    def test_repair_defaults(self):
218        """Test argument defaults for `deploy repair`."""
219        arguments = _test_parse_command(['repair'])
220        self._check_common_defaults(arguments)
221        self.assertFalse(arguments.stageusb)
222        self.assertFalse(arguments.install_firmware)
223        self.assertFalse(arguments.install_test_image)
224        self.assertTrue(arguments.reinstall_test_image)
225
226
227if __name__ == '__main__':
228    unittest.main()
229