Mike Frysinger | d03e6b5 | 2019-08-03 12:49:01 -0400 | [diff] [blame] | 1 | #!/usr/bin/python2 |
Aviv Keshet | 6f45526 | 2013-03-01 16:02:29 -0800 | [diff] [blame] | 2 | # pylint: disable-msg=C0111 |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 3 | |
Prashanth B | ee70731 | 2014-03-31 13:00:36 -0700 | [diff] [blame] | 4 | import json |
Dan Shi | ef5b53f | 2013-01-22 10:22:01 -0800 | [diff] [blame] | 5 | import os, unittest |
| 6 | |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 7 | import common |
Dan Shi | ef5b53f | 2013-01-22 10:22:01 -0800 | [diff] [blame] | 8 | |
jadmanski | 5f2bc28 | 2009-07-28 17:21:15 +0000 | [diff] [blame] | 9 | from autotest_lib.client.common_lib import control_data, autotemp |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 10 | |
| 11 | ControlData = control_data.ControlData |
| 12 | |
| 13 | CONTROL = """ |
mbligh | 93f4209 | 2008-07-18 01:01:58 +0000 | [diff] [blame] | 14 | AUTHOR = 'Author' |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 15 | DEPENDENCIES = "console, power" |
| 16 | DOC = \"\"\"\ |
| 17 | doc stuff\"\"\" |
| 18 | # EXPERIMENTAL should implicitly be False |
| 19 | NAME = 'nA' "mE" |
mbligh | 93f4209 | 2008-07-18 01:01:58 +0000 | [diff] [blame] | 20 | RUN_VERIFY = False |
| 21 | SYNC_COUNT = 2 |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 22 | TIME='short' |
mbligh | 93f4209 | 2008-07-18 01:01:58 +0000 | [diff] [blame] | 23 | TEST_CLASS=u'Kernel' |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 24 | TEST_CATEGORY='Stress' |
| 25 | TEST_TYPE='client' |
Dan Shi | ec1d47d | 2015-02-13 11:38:13 -0800 | [diff] [blame] | 26 | REQUIRE_SSP = False |
Shuqian Zhao | 9e68121 | 2015-09-18 16:11:07 -0700 | [diff] [blame] | 27 | ATTRIBUTES = "suite:smoke, suite:bvt" |
Christopher Wiley | 4a14056 | 2016-03-08 09:36:24 -0800 | [diff] [blame] | 28 | SUITE = "suite-listed-only-in-suite-line" |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 29 | """ |
| 30 | |
Dan Shi | f53d126 | 2017-06-19 11:25:25 -0700 | [diff] [blame] | 31 | # Control data being wrapped into step* functions. |
| 32 | WRAPPED_CONTROL = """ |
| 33 | def step_init(): |
| 34 | step0() |
| 35 | |
| 36 | def step0(): |
| 37 | AUTHOR = 'Author' |
| 38 | DEPENDENCIES = "console, power" |
| 39 | DOC = \"\"\"\ |
| 40 | doc stuff\"\"\" |
| 41 | # EXPERIMENTAL should implicitly be False |
| 42 | NAME = 'nA' "mE" |
| 43 | RUN_VERIFY = False |
| 44 | SYNC_COUNT = 2 |
| 45 | TIME='short' |
| 46 | TEST_CLASS=u'Kernel' |
| 47 | TEST_CATEGORY='Stress' |
| 48 | TEST_TYPE='client' |
Dan Shi | f53d126 | 2017-06-19 11:25:25 -0700 | [diff] [blame] | 49 | REQUIRE_SSP = False |
| 50 | ATTRIBUTES = "suite:smoke, suite:bvt" |
| 51 | SUITE = "suite-listed-only-in-suite-line" |
| 52 | MAX_RESULT_SIZE_KB = 20000 |
| 53 | |
| 54 | step_init() |
| 55 | """ |
| 56 | |
mbligh | d7cd983 | 2008-10-02 16:20:37 +0000 | [diff] [blame] | 57 | |
Allen Li | 3d718dc | 2017-02-08 15:04:32 -0800 | [diff] [blame] | 58 | class ControlDataTestCase(unittest.TestCase): |
| 59 | def setUp(self): |
| 60 | self._required_vars = control_data.REQUIRED_VARS |
| 61 | control_data.REQUIRED_VARS = set() |
| 62 | |
| 63 | |
| 64 | def tearDown(self): |
| 65 | control_data.REQUIRED_VARS = self._required_vars |
| 66 | |
| 67 | |
| 68 | def test_suite_tag_parts(self): |
| 69 | cd = ControlData({'suite': 'foo,bar'}, 'filename') |
| 70 | self.assertEqual(set(cd.suite_tag_parts), {'foo', 'bar'}) |
| 71 | |
| 72 | |
| 73 | def test_suite_tag_parts_empty_for_non_suite(self): |
| 74 | cd = ControlData({}, 'filename') |
| 75 | self.assertEqual(cd.suite_tag_parts, []) |
| 76 | |
| 77 | |
| 78 | |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 79 | class ParseControlTest(unittest.TestCase): |
| 80 | def setUp(self): |
jadmanski | 5f2bc28 | 2009-07-28 17:21:15 +0000 | [diff] [blame] | 81 | self.control_tmp = autotemp.tempfile(unique_id='control_unit', |
| 82 | text=True) |
| 83 | os.write(self.control_tmp.fd, CONTROL) |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 84 | |
| 85 | |
| 86 | def tearDown(self): |
jadmanski | 5f2bc28 | 2009-07-28 17:21:15 +0000 | [diff] [blame] | 87 | self.control_tmp.clean() |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 88 | |
| 89 | |
| 90 | def test_parse_control(self): |
jadmanski | 5f2bc28 | 2009-07-28 17:21:15 +0000 | [diff] [blame] | 91 | cd = control_data.parse_control(self.control_tmp.name, True) |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 92 | self.assertEquals(cd.author, "Author") |
| 93 | self.assertEquals(cd.dependencies, set(['console', 'power'])) |
| 94 | self.assertEquals(cd.doc, "doc stuff") |
| 95 | self.assertEquals(cd.experimental, False) |
| 96 | self.assertEquals(cd.name, "nAmE") |
| 97 | self.assertEquals(cd.run_verify, False) |
| 98 | self.assertEquals(cd.sync_count, 2) |
| 99 | self.assertEquals(cd.time, "short") |
| 100 | self.assertEquals(cd.test_class, "kernel") |
| 101 | self.assertEquals(cd.test_category, "stress") |
| 102 | self.assertEquals(cd.test_type, "client") |
Dan Shi | ec1d47d | 2015-02-13 11:38:13 -0800 | [diff] [blame] | 103 | self.assertEquals(cd.require_ssp, False) |
Shuqian Zhao | 9e68121 | 2015-09-18 16:11:07 -0700 | [diff] [blame] | 104 | self.assertEquals(cd.attributes, |
| 105 | set(["suite:smoke","suite:bvt","subsystem:default"])) |
Christopher Wiley | 4a14056 | 2016-03-08 09:36:24 -0800 | [diff] [blame] | 106 | self.assertEquals(cd.suite, |
| 107 | "bvt,smoke,suite-listed-only-in-suite-line") |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 108 | |
| 109 | |
Dan Shi | f53d126 | 2017-06-19 11:25:25 -0700 | [diff] [blame] | 110 | class ParseWrappedControlTest(unittest.TestCase): |
| 111 | """Test control data can be retrieved from wrapped step functions.""" |
| 112 | def setUp(self): |
| 113 | self.control_tmp = autotemp.tempfile(unique_id='wrapped_control_unit', |
| 114 | text=True) |
| 115 | os.write(self.control_tmp.fd, WRAPPED_CONTROL) |
| 116 | |
| 117 | |
| 118 | def tearDown(self): |
| 119 | self.control_tmp.clean() |
| 120 | |
| 121 | |
| 122 | def test_parse_control(self): |
| 123 | cd = control_data.parse_control(self.control_tmp.name, True) |
| 124 | self.assertEquals(cd.author, "Author") |
| 125 | self.assertEquals(cd.dependencies, set(['console', 'power'])) |
| 126 | self.assertEquals(cd.doc, "doc stuff") |
| 127 | self.assertEquals(cd.experimental, False) |
| 128 | self.assertEquals(cd.name, "nAmE") |
| 129 | self.assertEquals(cd.run_verify, False) |
| 130 | self.assertEquals(cd.sync_count, 2) |
| 131 | self.assertEquals(cd.time, "short") |
| 132 | self.assertEquals(cd.test_class, "kernel") |
| 133 | self.assertEquals(cd.test_category, "stress") |
| 134 | self.assertEquals(cd.test_type, "client") |
Dan Shi | f53d126 | 2017-06-19 11:25:25 -0700 | [diff] [blame] | 135 | self.assertEquals(cd.require_ssp, False) |
| 136 | self.assertEquals(cd.attributes, |
| 137 | set(["suite:smoke","suite:bvt","subsystem:default"])) |
| 138 | self.assertEquals(cd.suite, |
| 139 | "bvt,smoke,suite-listed-only-in-suite-line") |
| 140 | self.assertEquals(cd.max_result_size_KB, 20000) |
| 141 | |
| 142 | |
Prashanth B | ee70731 | 2014-03-31 13:00:36 -0700 | [diff] [blame] | 143 | class ParseControlFileBugTemplate(unittest.TestCase): |
| 144 | def setUp(self): |
| 145 | self.control_tmp = autotemp.tempfile(unique_id='control_unit', |
| 146 | text=True) |
| 147 | self.bug_template = { |
| 148 | 'owner': 'someone@something.org', |
| 149 | 'labels': ['a', 'b'], |
| 150 | 'status': None, |
| 151 | 'summary': None, |
| 152 | 'title': None, |
| 153 | 'cc': ['a@something, b@something'], |
| 154 | } |
| 155 | |
| 156 | |
| 157 | def tearDown(self): |
| 158 | self.control_tmp.clean() |
| 159 | |
| 160 | |
| 161 | def insert_bug_template(self, control_file_string): |
| 162 | """Insert a bug template into the control file string. |
| 163 | |
| 164 | @param control_file_string: A string of the control file contents |
| 165 | this test will run on. |
| 166 | |
| 167 | @return: The control file string with the BUG_TEMPLATE line. |
| 168 | """ |
| 169 | bug_template_line = 'BUG_TEMPLATE = %s' % json.dumps(self.bug_template) |
| 170 | return control_file_string + bug_template_line |
| 171 | |
| 172 | |
| 173 | def verify_bug_template(self, new_bug_template): |
| 174 | """Verify that the bug template given matches the original. |
| 175 | |
| 176 | @param new_bug_template: A bug template pulled off parsing the |
| 177 | control file. |
| 178 | |
| 179 | @raises AssetionError: If a value under a give key in the bug template |
| 180 | doesn't match the value in self.bug_template. |
| 181 | @raises KeyError: If a key in either bug template is missing. |
| 182 | """ |
| 183 | for key, value in new_bug_template.iteritems(): |
| 184 | self.assertEqual(value, self.bug_template[key]) |
| 185 | |
| 186 | |
| 187 | def test_bug_template_parsing(self): |
| 188 | """Basic parsing test for a bug templates in a test control file.""" |
| 189 | os.write(self.control_tmp.fd, self.insert_bug_template(CONTROL)) |
| 190 | cd = control_data.parse_control(self.control_tmp.name, True) |
| 191 | self.verify_bug_template(cd.bug_template) |
| 192 | |
| 193 | |
| 194 | def test_bug_template_list(self): |
| 195 | """Test that lists in the bug template can handle other datatypes.""" |
| 196 | self.bug_template['labels'].append({'foo': 'bar'}) |
| 197 | os.write(self.control_tmp.fd, self.insert_bug_template(CONTROL)) |
| 198 | cd = control_data.parse_control(self.control_tmp.name, True) |
| 199 | self.verify_bug_template(cd.bug_template) |
| 200 | |
| 201 | |
| 202 | def test_bad_template(self): |
| 203 | """Test that a bad bug template doesn't result in a bad control data.""" |
| 204 | self.bug_template = 'foobarbug_template' |
| 205 | os.write(self.control_tmp.fd, self.insert_bug_template(CONTROL)) |
| 206 | cd = control_data.parse_control(self.control_tmp.name, True) |
| 207 | self.assertFalse(hasattr(cd, 'bug_template')) |
| 208 | |
| 209 | |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 210 | class SetMethodTests(unittest.TestCase): |
| 211 | def setUp(self): |
| 212 | self.required_vars = control_data.REQUIRED_VARS |
| 213 | control_data.REQUIRED_VARS = set() |
| 214 | |
| 215 | |
| 216 | def tearDown(self): |
| 217 | control_data.REQUIRED_VARS = self.required_vars |
| 218 | |
| 219 | |
| 220 | def test_bool(self): |
mbligh | d7cd983 | 2008-10-02 16:20:37 +0000 | [diff] [blame] | 221 | cd = ControlData({}, 'filename') |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 222 | cd._set_bool('foo', 'False') |
| 223 | self.assertEquals(cd.foo, False) |
| 224 | cd._set_bool('foo', True) |
| 225 | self.assertEquals(cd.foo, True) |
| 226 | cd._set_bool('foo', 'FALSE') |
| 227 | self.assertEquals(cd.foo, False) |
| 228 | cd._set_bool('foo', 'true') |
| 229 | self.assertEquals(cd.foo, True) |
| 230 | self.assertRaises(ValueError, cd._set_bool, 'foo', '') |
| 231 | self.assertRaises(ValueError, cd._set_bool, 'foo', 1) |
| 232 | self.assertRaises(ValueError, cd._set_bool, 'foo', []) |
| 233 | self.assertRaises(ValueError, cd._set_bool, 'foo', None) |
| 234 | |
| 235 | |
| 236 | def test_int(self): |
mbligh | d7cd983 | 2008-10-02 16:20:37 +0000 | [diff] [blame] | 237 | cd = ControlData({}, 'filename') |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 238 | cd._set_int('foo', 0) |
| 239 | self.assertEquals(cd.foo, 0) |
| 240 | cd._set_int('foo', '0') |
| 241 | self.assertEquals(cd.foo, 0) |
| 242 | cd._set_int('foo', '-1', min=-2, max=10) |
| 243 | self.assertEquals(cd.foo, -1) |
| 244 | self.assertRaises(ValueError, cd._set_int, 'foo', 0, min=1) |
| 245 | self.assertRaises(ValueError, cd._set_int, 'foo', 1, max=0) |
| 246 | self.assertRaises(ValueError, cd._set_int, 'foo', 'x') |
| 247 | self.assertRaises(ValueError, cd._set_int, 'foo', '') |
| 248 | self.assertRaises(TypeError, cd._set_int, 'foo', None) |
| 249 | |
| 250 | |
| 251 | def test_set(self): |
mbligh | d7cd983 | 2008-10-02 16:20:37 +0000 | [diff] [blame] | 252 | cd = ControlData({}, 'filename') |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 253 | cd._set_set('foo', 'a') |
| 254 | self.assertEquals(cd.foo, set(['a'])) |
| 255 | cd._set_set('foo', 'a,b,c') |
| 256 | self.assertEquals(cd.foo, set(['a', 'b', 'c'])) |
| 257 | cd._set_set('foo', ' a , b , c ') |
| 258 | self.assertEquals(cd.foo, set(['a', 'b', 'c'])) |
| 259 | cd._set_set('foo', None) |
| 260 | self.assertEquals(cd.foo, set(['None'])) |
| 261 | |
| 262 | |
| 263 | def test_string(self): |
mbligh | d7cd983 | 2008-10-02 16:20:37 +0000 | [diff] [blame] | 264 | cd = ControlData({}, 'filename') |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 265 | cd._set_string('foo', 'a') |
| 266 | self.assertEquals(cd.foo, 'a') |
| 267 | cd._set_string('foo', 'b') |
| 268 | self.assertEquals(cd.foo, 'b') |
| 269 | cd._set_string('foo', 'B') |
| 270 | self.assertEquals(cd.foo, 'B') |
| 271 | cd._set_string('foo', 1) |
| 272 | self.assertEquals(cd.foo, '1') |
| 273 | cd._set_string('foo', None) |
| 274 | self.assertEquals(cd.foo, 'None') |
| 275 | cd._set_string('foo', []) |
| 276 | self.assertEquals(cd.foo, '[]') |
| 277 | |
| 278 | |
| 279 | def test_option(self): |
| 280 | options = ['a', 'b'] |
mbligh | d7cd983 | 2008-10-02 16:20:37 +0000 | [diff] [blame] | 281 | cd = ControlData({}, 'filename') |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 282 | cd._set_option('foo', 'a', options) |
| 283 | self.assertEquals(cd.foo, 'a') |
| 284 | cd._set_option('foo', 'b', options) |
| 285 | self.assertEquals(cd.foo, 'b') |
| 286 | cd._set_option('foo', 'B', options) |
| 287 | self.assertEquals(cd.foo, 'B') |
| 288 | self.assertRaises(ValueError, cd._set_option, |
| 289 | 'foo', 'x', options) |
| 290 | self.assertRaises(ValueError, cd._set_option, |
| 291 | 'foo', 1, options) |
| 292 | self.assertRaises(ValueError, cd._set_option, |
| 293 | 'foo', [], options) |
| 294 | self.assertRaises(ValueError, cd._set_option, |
| 295 | 'foo', None, options) |
| 296 | |
| 297 | |
Shuqian Zhao | 9e68121 | 2015-09-18 16:11:07 -0700 | [diff] [blame] | 298 | def test_set_attributes(self): |
| 299 | cd = ControlData({}, 'filename') |
| 300 | cd.set_attributes('suite:bvt') |
| 301 | self.assertEquals(cd.attributes, set(['suite:bvt', |
| 302 | 'subsystem:default'])) |
| 303 | cd.set_attributes('suite:bvt, subsystem:network') |
| 304 | self.assertEquals(cd.attributes, set(['suite:bvt', |
| 305 | 'subsystem:network'])) |
| 306 | |
| 307 | |
Dan Shi | ef5b53f | 2013-01-22 10:22:01 -0800 | [diff] [blame] | 308 | def test_get_test_time_index(self): |
| 309 | inputs = [time.upper() for time in |
| 310 | ControlData.TEST_TIME_LIST] |
| 311 | time_min_index = [ControlData.get_test_time_index(time) |
| 312 | for time in inputs] |
| 313 | expected_time_index = range(len(ControlData.TEST_TIME_LIST)) |
| 314 | self.assertEqual(time_min_index, expected_time_index) |
| 315 | |
| 316 | |
| 317 | def test_get_test_time_index_failure(self): |
| 318 | def fail(): |
| 319 | """Test function to raise ControlVariableException exception |
| 320 | for invalid TIME setting.""" |
| 321 | index = ControlData.get_test_time_index('some invalid TIME') |
| 322 | |
| 323 | self.assertRaises(control_data.ControlVariableException, fail) |
| 324 | |
| 325 | |
mbligh | 99c2c6f | 2008-07-11 18:15:46 +0000 | [diff] [blame] | 326 | # this is so the test can be run in standalone mode |
| 327 | if __name__ == '__main__': |
| 328 | unittest.main() |