You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
332 lines
11 KiB
332 lines
11 KiB
#!/usr/bin/python2
|
|
# pylint: disable-msg=C0111
|
|
|
|
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
|
|
import json
|
|
import os
|
|
import six
|
|
from six.moves import range
|
|
import unittest
|
|
|
|
import common
|
|
|
|
from autotest_lib.client.common_lib import control_data, autotemp
|
|
|
|
|
|
ControlData = control_data.ControlData
|
|
|
|
CONTROL = """
|
|
AUTHOR = 'Author'
|
|
DEPENDENCIES = "console, power"
|
|
DOC = \"\"\"\
|
|
doc stuff\"\"\"
|
|
# EXPERIMENTAL should implicitly be False
|
|
NAME = 'nA' "mE"
|
|
RUN_VERIFY = False
|
|
SYNC_COUNT = 2
|
|
TIME='short'
|
|
TEST_CLASS=u'Kernel'
|
|
TEST_CATEGORY='Stress'
|
|
TEST_TYPE='client'
|
|
REQUIRE_SSP = False
|
|
ATTRIBUTES = "suite:smoke, suite:bvt"
|
|
SUITE = "suite-listed-only-in-suite-line"
|
|
"""
|
|
|
|
# Control data being wrapped into step* functions.
|
|
WRAPPED_CONTROL = """
|
|
def step_init():
|
|
step0()
|
|
|
|
def step0():
|
|
AUTHOR = 'Author'
|
|
DEPENDENCIES = "console, power"
|
|
DOC = \"\"\"\
|
|
doc stuff\"\"\"
|
|
# EXPERIMENTAL should implicitly be False
|
|
NAME = 'nA' "mE"
|
|
RUN_VERIFY = False
|
|
SYNC_COUNT = 2
|
|
TIME='short'
|
|
TEST_CLASS=u'Kernel'
|
|
TEST_CATEGORY='Stress'
|
|
TEST_TYPE='client'
|
|
REQUIRE_SSP = False
|
|
ATTRIBUTES = "suite:smoke, suite:bvt"
|
|
SUITE = "suite-listed-only-in-suite-line"
|
|
MAX_RESULT_SIZE_KB = 20000
|
|
|
|
step_init()
|
|
"""
|
|
|
|
|
|
class ControlDataTestCase(unittest.TestCase):
|
|
def setUp(self):
|
|
self._required_vars = control_data.REQUIRED_VARS
|
|
control_data.REQUIRED_VARS = set()
|
|
|
|
|
|
def tearDown(self):
|
|
control_data.REQUIRED_VARS = self._required_vars
|
|
|
|
|
|
def test_suite_tag_parts(self):
|
|
cd = ControlData({'suite': 'foo,bar'}, 'filename')
|
|
self.assertEqual(set(cd.suite_tag_parts), {'foo', 'bar'})
|
|
|
|
|
|
def test_suite_tag_parts_empty_for_non_suite(self):
|
|
cd = ControlData({}, 'filename')
|
|
self.assertEqual(cd.suite_tag_parts, [])
|
|
|
|
|
|
|
|
class ParseControlTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.control_tmp = autotemp.tempfile(unique_id='control_unit',
|
|
text=True)
|
|
os.write(self.control_tmp.fd, str.encode(CONTROL))
|
|
|
|
|
|
def tearDown(self):
|
|
self.control_tmp.clean()
|
|
|
|
|
|
def test_parse_control(self):
|
|
cd = control_data.parse_control(self.control_tmp.name, True)
|
|
self.assertEqual(cd.author, "Author")
|
|
self.assertEqual(cd.dependencies, set(['console', 'power']))
|
|
self.assertEqual(cd.doc, "doc stuff")
|
|
self.assertEqual(cd.experimental, False)
|
|
self.assertEqual(cd.name, "nAmE")
|
|
self.assertEqual(cd.run_verify, False)
|
|
self.assertEqual(cd.sync_count, 2)
|
|
self.assertEqual(cd.time, "short")
|
|
self.assertEqual(cd.test_class, "kernel")
|
|
self.assertEqual(cd.test_category, "stress")
|
|
self.assertEqual(cd.test_type, "client")
|
|
self.assertEqual(cd.require_ssp, False)
|
|
self.assertEqual(cd.attributes, set(["suite:smoke", "suite:bvt"]))
|
|
self.assertEqual(cd.suite, "bvt,smoke,suite-listed-only-in-suite-line")
|
|
|
|
|
|
class ParseWrappedControlTest(unittest.TestCase):
|
|
"""Test control data can be retrieved from wrapped step functions."""
|
|
def setUp(self):
|
|
self.control_tmp = autotemp.tempfile(unique_id='wrapped_control_unit',
|
|
text=True)
|
|
os.write(self.control_tmp.fd, str.encode(WRAPPED_CONTROL))
|
|
|
|
|
|
def tearDown(self):
|
|
self.control_tmp.clean()
|
|
|
|
|
|
def test_parse_control(self):
|
|
cd = control_data.parse_control(self.control_tmp.name, True)
|
|
self.assertEqual(cd.author, "Author")
|
|
self.assertEqual(cd.dependencies, set(['console', 'power']))
|
|
self.assertEqual(cd.doc, "doc stuff")
|
|
self.assertEqual(cd.experimental, False)
|
|
self.assertEqual(cd.name, "nAmE")
|
|
self.assertEqual(cd.run_verify, False)
|
|
self.assertEqual(cd.sync_count, 2)
|
|
self.assertEqual(cd.time, "short")
|
|
self.assertEqual(cd.test_class, "kernel")
|
|
self.assertEqual(cd.test_category, "stress")
|
|
self.assertEqual(cd.test_type, "client")
|
|
self.assertEqual(cd.require_ssp, False)
|
|
self.assertEqual(cd.attributes, set(["suite:smoke", "suite:bvt"]))
|
|
self.assertEqual(cd.suite, "bvt,smoke,suite-listed-only-in-suite-line")
|
|
self.assertEqual(cd.max_result_size_KB, 20000)
|
|
|
|
|
|
class ParseControlFileBugTemplate(unittest.TestCase):
|
|
def setUp(self):
|
|
self.control_tmp = autotemp.tempfile(unique_id='control_unit',
|
|
text=True)
|
|
self.bug_template = {
|
|
'owner': 'someone@something.org',
|
|
'labels': ['a', 'b'],
|
|
'status': None,
|
|
'summary': None,
|
|
'title': None,
|
|
'cc': ['a@something, b@something'],
|
|
}
|
|
|
|
|
|
def tearDown(self):
|
|
self.control_tmp.clean()
|
|
|
|
|
|
def insert_bug_template(self, control_file_string):
|
|
"""Insert a bug template into the control file string.
|
|
|
|
@param control_file_string: A string of the control file contents
|
|
this test will run on.
|
|
|
|
@return: The control file string with the BUG_TEMPLATE line.
|
|
"""
|
|
bug_template_line = 'BUG_TEMPLATE = %s' % json.dumps(self.bug_template)
|
|
return control_file_string + bug_template_line
|
|
|
|
|
|
def verify_bug_template(self, new_bug_template):
|
|
"""Verify that the bug template given matches the original.
|
|
|
|
@param new_bug_template: A bug template pulled off parsing the
|
|
control file.
|
|
|
|
@raises AssetionError: If a value under a give key in the bug template
|
|
doesn't match the value in self.bug_template.
|
|
@raises KeyError: If a key in either bug template is missing.
|
|
"""
|
|
for key, value in six.iteritems(new_bug_template):
|
|
self.assertEqual(value, self.bug_template[key])
|
|
|
|
|
|
def test_bug_template_parsing(self):
|
|
"""Basic parsing test for a bug templates in a test control file."""
|
|
os.write(self.control_tmp.fd,
|
|
str.encode(self.insert_bug_template(CONTROL)))
|
|
cd = control_data.parse_control(self.control_tmp.name, True)
|
|
self.verify_bug_template(cd.bug_template)
|
|
|
|
|
|
def test_bug_template_list(self):
|
|
"""Test that lists in the bug template can handle other datatypes."""
|
|
self.bug_template['labels'].append({'foo': 'bar'})
|
|
os.write(self.control_tmp.fd,
|
|
str.encode(self.insert_bug_template(CONTROL)))
|
|
cd = control_data.parse_control(self.control_tmp.name, True)
|
|
self.verify_bug_template(cd.bug_template)
|
|
|
|
|
|
def test_bad_template(self):
|
|
"""Test that a bad bug template doesn't result in a bad control data."""
|
|
self.bug_template = 'foobarbug_template'
|
|
os.write(self.control_tmp.fd,
|
|
str.encode(self.insert_bug_template(CONTROL)))
|
|
cd = control_data.parse_control(self.control_tmp.name, True)
|
|
self.assertFalse(hasattr(cd, 'bug_template'))
|
|
|
|
|
|
class SetMethodTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.required_vars = control_data.REQUIRED_VARS
|
|
control_data.REQUIRED_VARS = set()
|
|
|
|
|
|
def tearDown(self):
|
|
control_data.REQUIRED_VARS = self.required_vars
|
|
|
|
|
|
def test_bool(self):
|
|
cd = ControlData({}, 'filename')
|
|
cd._set_bool('foo', 'False')
|
|
self.assertEqual(cd.foo, False)
|
|
cd._set_bool('foo', True)
|
|
self.assertEqual(cd.foo, True)
|
|
cd._set_bool('foo', 'FALSE')
|
|
self.assertEqual(cd.foo, False)
|
|
cd._set_bool('foo', 'true')
|
|
self.assertEqual(cd.foo, True)
|
|
self.assertRaises(ValueError, cd._set_bool, 'foo', '')
|
|
self.assertRaises(ValueError, cd._set_bool, 'foo', 1)
|
|
self.assertRaises(ValueError, cd._set_bool, 'foo', [])
|
|
self.assertRaises(ValueError, cd._set_bool, 'foo', None)
|
|
|
|
|
|
def test_int(self):
|
|
cd = ControlData({}, 'filename')
|
|
cd._set_int('foo', 0)
|
|
self.assertEqual(cd.foo, 0)
|
|
cd._set_int('foo', '0')
|
|
self.assertEqual(cd.foo, 0)
|
|
cd._set_int('foo', '-1', min=-2, max=10)
|
|
self.assertEqual(cd.foo, -1)
|
|
self.assertRaises(ValueError, cd._set_int, 'foo', 0, min=1)
|
|
self.assertRaises(ValueError, cd._set_int, 'foo', 1, max=0)
|
|
self.assertRaises(ValueError, cd._set_int, 'foo', 'x')
|
|
self.assertRaises(ValueError, cd._set_int, 'foo', '')
|
|
self.assertRaises(TypeError, cd._set_int, 'foo', None)
|
|
|
|
|
|
def test_set(self):
|
|
cd = ControlData({}, 'filename')
|
|
cd._set_set('foo', 'a')
|
|
self.assertEqual(cd.foo, set(['a']))
|
|
cd._set_set('foo', 'a,b,c')
|
|
self.assertEqual(cd.foo, set(['a', 'b', 'c']))
|
|
cd._set_set('foo', ' a , b , c ')
|
|
self.assertEqual(cd.foo, set(['a', 'b', 'c']))
|
|
cd._set_set('foo', None)
|
|
self.assertEqual(cd.foo, set(['None']))
|
|
|
|
|
|
def test_string(self):
|
|
cd = ControlData({}, 'filename')
|
|
cd._set_string('foo', 'a')
|
|
self.assertEqual(cd.foo, 'a')
|
|
cd._set_string('foo', 'b')
|
|
self.assertEqual(cd.foo, 'b')
|
|
cd._set_string('foo', 'B')
|
|
self.assertEqual(cd.foo, 'B')
|
|
cd._set_string('foo', 1)
|
|
self.assertEqual(cd.foo, '1')
|
|
cd._set_string('foo', None)
|
|
self.assertEqual(cd.foo, 'None')
|
|
cd._set_string('foo', [])
|
|
self.assertEqual(cd.foo, '[]')
|
|
|
|
|
|
def test_option(self):
|
|
options = ['a', 'b']
|
|
cd = ControlData({}, 'filename')
|
|
cd._set_option('foo', 'a', options)
|
|
self.assertEqual(cd.foo, 'a')
|
|
cd._set_option('foo', 'b', options)
|
|
self.assertEqual(cd.foo, 'b')
|
|
cd._set_option('foo', 'B', options)
|
|
self.assertEqual(cd.foo, 'B')
|
|
self.assertRaises(ValueError, cd._set_option,
|
|
'foo', 'x', options)
|
|
self.assertRaises(ValueError, cd._set_option,
|
|
'foo', 1, options)
|
|
self.assertRaises(ValueError, cd._set_option,
|
|
'foo', [], options)
|
|
self.assertRaises(ValueError, cd._set_option,
|
|
'foo', None, options)
|
|
|
|
|
|
def test_set_attributes(self):
|
|
cd = ControlData({}, 'filename')
|
|
cd.set_attributes('suite:bvt')
|
|
self.assertEqual(cd.attributes, set(['suite:bvt']))
|
|
|
|
|
|
def test_get_test_time_index(self):
|
|
inputs = [time.upper() for time in
|
|
ControlData.TEST_TIME_LIST]
|
|
time_min_index = [ControlData.get_test_time_index(time)
|
|
for time in inputs]
|
|
expected_time_index = list(range(len(ControlData.TEST_TIME_LIST)))
|
|
self.assertEqual(time_min_index, expected_time_index)
|
|
|
|
|
|
def test_get_test_time_index_failure(self):
|
|
def fail():
|
|
"""Test function to raise ControlVariableException exception
|
|
for invalid TIME setting."""
|
|
index = ControlData.get_test_time_index('some invalid TIME')
|
|
|
|
self.assertRaises(control_data.ControlVariableException, fail)
|
|
|
|
|
|
# this is so the test can be run in standalone mode
|
|
if __name__ == '__main__':
|
|
unittest.main()
|