• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/python
2# pylint: disable-msg=C0111
3
4import json
5import os, unittest
6
7import common
8
9from autotest_lib.client.common_lib import control_data, autotemp
10
11ControlData = control_data.ControlData
12
13CONTROL = """
14AUTHOR = 'Author'
15DEPENDENCIES = "console, power"
16DOC = \"\"\"\
17doc stuff\"\"\"
18# EXPERIMENTAL should implicitly be False
19NAME = 'nA' "mE"
20RUN_VERIFY = False
21SYNC_COUNT = 2
22TIME='short'
23TEST_CLASS=u'Kernel'
24TEST_CATEGORY='Stress'
25TEST_TYPE='client'
26RETRIES = 5
27REQUIRE_SSP = False
28ATTRIBUTES = "suite:smoke, suite:bvt"
29SUITE = "suite-listed-only-in-suite-line"
30"""
31
32
33class ControlDataTestCase(unittest.TestCase):
34    def setUp(self):
35        self._required_vars = control_data.REQUIRED_VARS
36        control_data.REQUIRED_VARS = set()
37
38
39    def tearDown(self):
40        control_data.REQUIRED_VARS = self._required_vars
41
42
43    def test_suite_tag_parts(self):
44        cd = ControlData({'suite': 'foo,bar'}, 'filename')
45        self.assertEqual(set(cd.suite_tag_parts), {'foo', 'bar'})
46
47
48    def test_suite_tag_parts_empty_for_non_suite(self):
49        cd = ControlData({}, 'filename')
50        self.assertEqual(cd.suite_tag_parts, [])
51
52
53
54class ParseControlTest(unittest.TestCase):
55    def setUp(self):
56        self.control_tmp = autotemp.tempfile(unique_id='control_unit',
57                                             text=True)
58        os.write(self.control_tmp.fd, CONTROL)
59
60
61    def tearDown(self):
62        self.control_tmp.clean()
63
64
65    def test_parse_control(self):
66        cd = control_data.parse_control(self.control_tmp.name, True)
67        self.assertEquals(cd.author, "Author")
68        self.assertEquals(cd.dependencies, set(['console', 'power']))
69        self.assertEquals(cd.doc, "doc stuff")
70        self.assertEquals(cd.experimental, False)
71        self.assertEquals(cd.name, "nAmE")
72        self.assertEquals(cd.run_verify, False)
73        self.assertEquals(cd.sync_count, 2)
74        self.assertEquals(cd.time, "short")
75        self.assertEquals(cd.test_class, "kernel")
76        self.assertEquals(cd.test_category, "stress")
77        self.assertEquals(cd.test_type, "client")
78        self.assertEquals(cd.retries, 5)
79        self.assertEquals(cd.require_ssp, False)
80        self.assertEquals(cd.attributes,
81                          set(["suite:smoke","suite:bvt","subsystem:default"]))
82        self.assertEquals(cd.suite,
83                          "bvt,smoke,suite-listed-only-in-suite-line")
84
85
86class ParseControlFileBugTemplate(unittest.TestCase):
87    def setUp(self):
88        self.control_tmp = autotemp.tempfile(unique_id='control_unit',
89                                             text=True)
90        self.bug_template = {
91            'owner': 'someone@something.org',
92            'labels': ['a', 'b'],
93            'status': None,
94            'summary': None,
95            'title': None,
96            'cc': ['a@something, b@something'],
97        }
98
99
100    def tearDown(self):
101        self.control_tmp.clean()
102
103
104    def insert_bug_template(self, control_file_string):
105        """Insert a bug template into the control file string.
106
107        @param control_file_string: A string of the control file contents
108            this test will run on.
109
110        @return: The control file string with the BUG_TEMPLATE line.
111        """
112        bug_template_line = 'BUG_TEMPLATE = %s' % json.dumps(self.bug_template)
113        return control_file_string + bug_template_line
114
115
116    def verify_bug_template(self, new_bug_template):
117        """Verify that the bug template given matches the original.
118
119        @param new_bug_template: A bug template pulled off parsing the
120            control file.
121
122        @raises AssetionError: If a value under a give key in the bug template
123            doesn't match the value in self.bug_template.
124        @raises KeyError: If a key in either bug template is missing.
125        """
126        for key, value in new_bug_template.iteritems():
127            self.assertEqual(value, self.bug_template[key])
128
129
130    def test_bug_template_parsing(self):
131        """Basic parsing test for a bug templates in a test control file."""
132        os.write(self.control_tmp.fd, self.insert_bug_template(CONTROL))
133        cd = control_data.parse_control(self.control_tmp.name, True)
134        self.verify_bug_template(cd.bug_template)
135
136
137    def test_bug_template_list(self):
138        """Test that lists in the bug template can handle other datatypes."""
139        self.bug_template['labels'].append({'foo': 'bar'})
140        os.write(self.control_tmp.fd, self.insert_bug_template(CONTROL))
141        cd = control_data.parse_control(self.control_tmp.name, True)
142        self.verify_bug_template(cd.bug_template)
143
144
145    def test_bad_template(self):
146        """Test that a bad bug template doesn't result in a bad control data."""
147        self.bug_template = 'foobarbug_template'
148        os.write(self.control_tmp.fd, self.insert_bug_template(CONTROL))
149        cd = control_data.parse_control(self.control_tmp.name, True)
150        self.assertFalse(hasattr(cd, 'bug_template'))
151
152
153class SetMethodTests(unittest.TestCase):
154    def setUp(self):
155        self.required_vars = control_data.REQUIRED_VARS
156        control_data.REQUIRED_VARS = set()
157
158
159    def tearDown(self):
160        control_data.REQUIRED_VARS = self.required_vars
161
162
163    def test_bool(self):
164        cd = ControlData({}, 'filename')
165        cd._set_bool('foo', 'False')
166        self.assertEquals(cd.foo, False)
167        cd._set_bool('foo', True)
168        self.assertEquals(cd.foo, True)
169        cd._set_bool('foo', 'FALSE')
170        self.assertEquals(cd.foo, False)
171        cd._set_bool('foo', 'true')
172        self.assertEquals(cd.foo, True)
173        self.assertRaises(ValueError, cd._set_bool, 'foo', '')
174        self.assertRaises(ValueError, cd._set_bool, 'foo', 1)
175        self.assertRaises(ValueError, cd._set_bool, 'foo', [])
176        self.assertRaises(ValueError, cd._set_bool, 'foo', None)
177
178
179    def test_int(self):
180        cd = ControlData({}, 'filename')
181        cd._set_int('foo', 0)
182        self.assertEquals(cd.foo, 0)
183        cd._set_int('foo', '0')
184        self.assertEquals(cd.foo, 0)
185        cd._set_int('foo', '-1', min=-2, max=10)
186        self.assertEquals(cd.foo, -1)
187        self.assertRaises(ValueError, cd._set_int, 'foo', 0, min=1)
188        self.assertRaises(ValueError, cd._set_int, 'foo', 1, max=0)
189        self.assertRaises(ValueError, cd._set_int, 'foo', 'x')
190        self.assertRaises(ValueError, cd._set_int, 'foo', '')
191        self.assertRaises(TypeError, cd._set_int, 'foo', None)
192
193
194    def test_set(self):
195        cd = ControlData({}, 'filename')
196        cd._set_set('foo', 'a')
197        self.assertEquals(cd.foo, set(['a']))
198        cd._set_set('foo', 'a,b,c')
199        self.assertEquals(cd.foo, set(['a', 'b', 'c']))
200        cd._set_set('foo', ' a , b , c     ')
201        self.assertEquals(cd.foo, set(['a', 'b', 'c']))
202        cd._set_set('foo', None)
203        self.assertEquals(cd.foo, set(['None']))
204
205
206    def test_string(self):
207        cd = ControlData({}, 'filename')
208        cd._set_string('foo', 'a')
209        self.assertEquals(cd.foo, 'a')
210        cd._set_string('foo', 'b')
211        self.assertEquals(cd.foo, 'b')
212        cd._set_string('foo', 'B')
213        self.assertEquals(cd.foo, 'B')
214        cd._set_string('foo', 1)
215        self.assertEquals(cd.foo, '1')
216        cd._set_string('foo', None)
217        self.assertEquals(cd.foo, 'None')
218        cd._set_string('foo', [])
219        self.assertEquals(cd.foo, '[]')
220
221
222    def test_option(self):
223        options = ['a', 'b']
224        cd = ControlData({}, 'filename')
225        cd._set_option('foo', 'a', options)
226        self.assertEquals(cd.foo, 'a')
227        cd._set_option('foo', 'b', options)
228        self.assertEquals(cd.foo, 'b')
229        cd._set_option('foo', 'B', options)
230        self.assertEquals(cd.foo, 'B')
231        self.assertRaises(ValueError, cd._set_option,
232                          'foo', 'x', options)
233        self.assertRaises(ValueError, cd._set_option,
234                          'foo', 1, options)
235        self.assertRaises(ValueError, cd._set_option,
236                          'foo', [], options)
237        self.assertRaises(ValueError, cd._set_option,
238                          'foo', None, options)
239
240
241    def test_set_attributes(self):
242        cd = ControlData({}, 'filename')
243        cd.set_attributes('suite:bvt')
244        self.assertEquals(cd.attributes, set(['suite:bvt',
245                                              'subsystem:default']))
246        cd.set_attributes('suite:bvt, subsystem:network')
247        self.assertEquals(cd.attributes, set(['suite:bvt',
248                                              'subsystem:network']))
249
250
251    def test_get_test_time_index(self):
252        inputs = [time.upper() for time in
253                  ControlData.TEST_TIME_LIST]
254        time_min_index = [ControlData.get_test_time_index(time)
255                          for time in inputs]
256        expected_time_index = range(len(ControlData.TEST_TIME_LIST))
257        self.assertEqual(time_min_index, expected_time_index)
258
259
260    def test_get_test_time_index_failure(self):
261        def fail():
262            """Test function to raise ControlVariableException exception
263            for invalid TIME setting."""
264            index = ControlData.get_test_time_index('some invalid TIME')
265
266        self.assertRaises(control_data.ControlVariableException, fail)
267
268
269# this is so the test can be run in standalone mode
270if __name__ == '__main__':
271    unittest.main()
272