showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 1 | #!/usr/bin/python |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 2 | |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 3 | import re, unittest |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 4 | import common |
showard | 250d84d | 2010-01-12 21:59:48 +0000 | [diff] [blame^] | 5 | from autotest_lib.frontend import setup_django_environment |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 6 | from autotest_lib.frontend import setup_test_environment |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 7 | from autotest_lib.client.common_lib.test_utils import mock |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 8 | from django.db import connection |
showard | 250d84d | 2010-01-12 21:59:48 +0000 | [diff] [blame^] | 9 | from autotest_lib.frontend.tko import models, rpc_interface |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 10 | |
| 11 | # this will need to be updated when the view changes for the test to be |
| 12 | # consistent with reality |
| 13 | _CREATE_TEST_VIEW = """ |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 14 | CREATE VIEW tko_test_view_2 AS |
| 15 | SELECT tko_tests.test_idx AS test_idx, |
| 16 | tko_tests.job_idx AS job_idx, |
| 17 | tko_tests.test AS test_name, |
| 18 | tko_tests.subdir AS subdir, |
| 19 | tko_tests.kernel_idx AS kernel_idx, |
| 20 | tko_tests.status AS status_idx, |
| 21 | tko_tests.reason AS reason, |
| 22 | tko_tests.machine_idx AS machine_idx, |
| 23 | tko_tests.started_time AS test_started_time, |
| 24 | tko_tests.finished_time AS test_finished_time, |
| 25 | tko_jobs.tag AS job_tag, |
| 26 | tko_jobs.label AS job_name, |
| 27 | tko_jobs.username AS job_owner, |
| 28 | tko_jobs.queued_time AS job_queued_time, |
| 29 | tko_jobs.started_time AS job_started_time, |
| 30 | tko_jobs.finished_time AS job_finished_time, |
| 31 | tko_jobs.afe_job_id AS afe_job_id, |
| 32 | tko_machines.hostname AS hostname, |
| 33 | tko_machines.machine_group AS platform, |
| 34 | tko_machines.owner AS machine_owner, |
| 35 | tko_kernels.kernel_hash AS kernel_hash, |
| 36 | tko_kernels.base AS kernel_base, |
| 37 | tko_kernels.printable AS kernel, |
| 38 | tko_status.word AS status |
| 39 | FROM tko_tests |
| 40 | INNER JOIN tko_jobs ON tko_jobs.job_idx = tko_tests.job_idx |
| 41 | INNER JOIN tko_machines ON tko_machines.machine_idx = tko_jobs.machine_idx |
| 42 | INNER JOIN tko_kernels ON tko_kernels.kernel_idx = tko_tests.kernel_idx |
| 43 | INNER JOIN tko_status ON tko_status.status_idx = tko_tests.status; |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 44 | """ |
| 45 | |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 46 | # this will need to be updated if the table schemas change (or removed if we |
| 47 | # add proper primary keys) |
| 48 | _CREATE_ITERATION_ATTRIBUTES = """ |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 49 | CREATE TABLE "tko_iteration_attributes" ( |
| 50 | "test_idx" integer NOT NULL REFERENCES "tko_tests" ("test_idx"), |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 51 | "iteration" integer NOT NULL, |
| 52 | "attribute" varchar(90) NOT NULL, |
| 53 | "value" varchar(300) NOT NULL |
| 54 | ); |
| 55 | """ |
| 56 | |
| 57 | _CREATE_ITERATION_RESULTS = """ |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 58 | CREATE TABLE "tko_iteration_result" ( |
| 59 | "test_idx" integer NOT NULL REFERENCES "tko_tests" ("test_idx"), |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 60 | "iteration" integer NOT NULL, |
| 61 | "attribute" varchar(90) NOT NULL, |
| 62 | "value" numeric(12, 31) NULL |
| 63 | ); |
| 64 | """ |
| 65 | |
| 66 | |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 67 | def setup_test_view(): |
| 68 | """ |
| 69 | Django has no way to actually represent a view; we simply create a model for |
| 70 | TestView. This means when we syncdb, Django will create a table for it. |
| 71 | So manually remove that table and replace it with a view. |
| 72 | """ |
| 73 | cursor = connection.cursor() |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 74 | cursor.execute('DROP TABLE tko_test_view_2') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 75 | cursor.execute(_CREATE_TEST_VIEW) |
| 76 | |
| 77 | |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 78 | def fix_iteration_tables(): |
| 79 | """ |
| 80 | Since iteration tables don't have any real primary key, we "fake" one in the |
| 81 | Django models. So fix up the generated schema to match the real schema. |
| 82 | """ |
| 83 | cursor = connection.cursor() |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 84 | cursor.execute('DROP TABLE tko_iteration_attributes') |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 85 | cursor.execute(_CREATE_ITERATION_ATTRIBUTES) |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 86 | cursor.execute('DROP TABLE tko_iteration_result') |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 87 | cursor.execute(_CREATE_ITERATION_RESULTS) |
| 88 | |
| 89 | |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 90 | class RpcInterfaceTest(unittest.TestCase): |
| 91 | def setUp(self): |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 92 | self._god = mock.mock_god() |
showard | 8bfb5cb | 2009-10-07 20:49:15 +0000 | [diff] [blame] | 93 | self._god.stub_with(models.TempManager, '_get_column_names', |
| 94 | self._get_column_names_for_sqlite3) |
showard | d2b0c88 | 2009-10-19 18:34:11 +0000 | [diff] [blame] | 95 | self._god.stub_with(models.TempManager, '_cursor_rowcount', |
| 96 | self._cursor_rowcount_for_sqlite3) |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 97 | |
| 98 | # add some functions to SQLite for MySQL compatibility |
| 99 | connection.cursor() # ensure connection is alive |
| 100 | connection.connection.create_function('if', 3, self._sqlite_if) |
| 101 | connection.connection.create_function('find_in_set', 2, |
| 102 | self._sqlite_find_in_set) |
| 103 | |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 104 | setup_test_environment.set_up() |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 105 | fix_iteration_tables() |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 106 | setup_test_view() |
| 107 | self._create_initial_data() |
| 108 | |
| 109 | |
showard | d2b0c88 | 2009-10-19 18:34:11 +0000 | [diff] [blame] | 110 | def _cursor_rowcount_for_sqlite3(self, cursor): |
| 111 | return len(cursor.fetchall()) |
| 112 | |
| 113 | |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 114 | def _sqlite_find_in_set(self, needle, haystack): |
| 115 | return needle in haystack.split(',') |
| 116 | |
| 117 | |
| 118 | def _sqlite_if(self, condition, true_result, false_result): |
| 119 | if condition: |
| 120 | return true_result |
| 121 | return false_result |
| 122 | |
| 123 | |
| 124 | # sqlite takes any columns that don't have aliases and names them |
| 125 | # "table_name"."column_name". we map these to just column_name. |
| 126 | _SQLITE_AUTO_COLUMN_ALIAS_RE = re.compile(r'".+"\."(.+)"') |
| 127 | |
| 128 | |
| 129 | def _get_column_names_for_sqlite3(self, cursor): |
| 130 | names = [column_info[0] for column_info in cursor.description] |
| 131 | |
| 132 | # replace all "table_name"."column_name" constructs with just |
| 133 | # column_name |
| 134 | for i, name in enumerate(names): |
| 135 | match = self._SQLITE_AUTO_COLUMN_ALIAS_RE.match(name) |
| 136 | if match: |
| 137 | names[i] = match.group(1) |
| 138 | |
| 139 | return names |
| 140 | |
| 141 | |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 142 | def tearDown(self): |
| 143 | setup_test_environment.tear_down() |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 144 | self._god.unstub_all() |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 145 | |
| 146 | |
| 147 | def _create_initial_data(self): |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 148 | machine = models.Machine.objects.create(hostname='myhost') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 149 | |
showard | c478040 | 2009-08-31 18:31:34 +0000 | [diff] [blame] | 150 | # create basic objects |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 151 | kernel_name = 'mykernel1' |
| 152 | kernel1 = models.Kernel.objects.create(kernel_hash=kernel_name, |
| 153 | base=kernel_name, |
| 154 | printable=kernel_name) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 155 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 156 | kernel_name = 'mykernel2' |
| 157 | kernel2 = models.Kernel.objects.create(kernel_hash=kernel_name, |
| 158 | base=kernel_name, |
| 159 | printable=kernel_name) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 160 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 161 | good_status = models.Status.objects.create(word='GOOD') |
| 162 | failed_status = models.Status.objects.create(word='FAILED') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 163 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 164 | job1 = models.Job.objects.create(tag='1-myjobtag1', label='myjob1', |
| 165 | username='myuser', machine=machine) |
| 166 | job2 = models.Job.objects.create(tag='2-myjobtag2', label='myjob2', |
| 167 | username='myuser', machine=machine) |
| 168 | |
| 169 | job1_test1 = models.Test.objects.create(job=job1, test='mytest1', |
| 170 | kernel=kernel1, |
| 171 | status=good_status, |
| 172 | machine=machine) |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 173 | self.first_test = job1_test1 |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 174 | job1_test2 = models.Test.objects.create(job=job1, test='mytest2', |
| 175 | kernel=kernel1, |
| 176 | status=failed_status, |
| 177 | machine=machine) |
| 178 | job2_test1 = models.Test.objects.create(job=job2, test='kernbench', |
| 179 | kernel=kernel2, |
| 180 | status=good_status, |
| 181 | machine=machine) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 182 | |
showard | c478040 | 2009-08-31 18:31:34 +0000 | [diff] [blame] | 183 | # create test attributes, test labels, and iterations |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 184 | # like Noah's Ark, include two of each...just in case there's a bug with |
| 185 | # multiple related items |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 186 | models.TestAttribute.objects.create(test=job1_test1, attribute='myattr', |
| 187 | value='myval') |
| 188 | models.TestAttribute.objects.create(test=job1_test1, |
| 189 | attribute='myattr2', value='myval2') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 190 | |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 191 | self._add_iteration_keyval('tko_iteration_attributes', test=job1_test1, |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 192 | iteration=1, attribute='iattr', |
| 193 | value='ival') |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 194 | self._add_iteration_keyval('tko_iteration_attributes', test=job1_test1, |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 195 | iteration=1, attribute='iattr2', |
| 196 | value='ival2') |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 197 | self._add_iteration_keyval('tko_iteration_result', test=job1_test1, |
showard | c478040 | 2009-08-31 18:31:34 +0000 | [diff] [blame] | 198 | iteration=1, attribute='iresult', value=1) |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 199 | self._add_iteration_keyval('tko_iteration_result', test=job1_test1, |
showard | c478040 | 2009-08-31 18:31:34 +0000 | [diff] [blame] | 200 | iteration=1, attribute='iresult2', value=2) |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 201 | self._add_iteration_keyval('tko_iteration_result', test=job1_test1, |
showard | c478040 | 2009-08-31 18:31:34 +0000 | [diff] [blame] | 202 | iteration=2, attribute='iresult', value=3) |
showard | eab66ce | 2009-12-23 00:03:56 +0000 | [diff] [blame] | 203 | self._add_iteration_keyval('tko_iteration_result', test=job1_test1, |
showard | c478040 | 2009-08-31 18:31:34 +0000 | [diff] [blame] | 204 | iteration=2, attribute='iresult2', value=4) |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 205 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 206 | label1 = models.TestLabel.objects.create(name='testlabel1') |
| 207 | label2 = models.TestLabel.objects.create(name='testlabel2') |
| 208 | |
| 209 | label1.tests.add(job1_test1) |
| 210 | label2.tests.add(job1_test1) |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 211 | |
| 212 | |
| 213 | def _add_iteration_keyval(self, table, test, iteration, attribute, value): |
| 214 | cursor = connection.cursor() |
| 215 | cursor.execute('INSERT INTO %s ' 'VALUES (%%s, %%s, %%s, %%s)' % table, |
| 216 | (test.test_idx, iteration, attribute, value)) |
| 217 | |
| 218 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 219 | def _check_for_get_test_views(self, test): |
| 220 | self.assertEquals(test['test_name'], 'mytest1') |
| 221 | self.assertEquals(test['job_tag'], '1-myjobtag1') |
| 222 | self.assertEquals(test['job_name'], 'myjob1') |
| 223 | self.assertEquals(test['job_owner'], 'myuser') |
| 224 | self.assertEquals(test['status'], 'GOOD') |
| 225 | self.assertEquals(test['hostname'], 'myhost') |
| 226 | self.assertEquals(test['kernel'], 'mykernel1') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 227 | |
| 228 | |
| 229 | def test_get_detailed_test_views(self): |
| 230 | test = rpc_interface.get_detailed_test_views()[0] |
| 231 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 232 | self._check_for_get_test_views(test) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 233 | |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 234 | self.assertEquals(test['attributes'], {'myattr': 'myval', |
| 235 | 'myattr2': 'myval2'}) |
| 236 | self.assertEquals(test['iterations'], [{'attr': {'iattr': 'ival', |
| 237 | 'iattr2': 'ival2'}, |
| 238 | 'perf': {'iresult': 1, |
showard | c478040 | 2009-08-31 18:31:34 +0000 | [diff] [blame] | 239 | 'iresult2': 2}}, |
| 240 | {'attr': {}, |
| 241 | 'perf': {'iresult': 3, |
| 242 | 'iresult2': 4}}]) |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 243 | self.assertEquals(test['labels'], ['testlabel1', 'testlabel2']) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 244 | |
| 245 | |
| 246 | def test_test_attributes(self): |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 247 | rpc_interface.set_test_attribute('foo', 'bar', test_name='mytest1') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 248 | test = rpc_interface.get_detailed_test_views()[0] |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 249 | self.assertEquals(test['attributes'], {'foo': 'bar', |
| 250 | 'myattr': 'myval', |
| 251 | 'myattr2': 'myval2'}) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 252 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 253 | rpc_interface.set_test_attribute('foo', 'goo', test_name='mytest1') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 254 | test = rpc_interface.get_detailed_test_views()[0] |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 255 | self.assertEquals(test['attributes'], {'foo': 'goo', |
| 256 | 'myattr': 'myval', |
| 257 | 'myattr2': 'myval2'}) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 258 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 259 | rpc_interface.set_test_attribute('foo', None, test_name='mytest1') |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 260 | test = rpc_interface.get_detailed_test_views()[0] |
showard | 68693f7 | 2009-05-20 00:31:53 +0000 | [diff] [blame] | 261 | self.assertEquals(test['attributes'], {'myattr': 'myval', |
| 262 | 'myattr2': 'myval2'}) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 263 | |
| 264 | |
| 265 | def test_immutable_attributes(self): |
| 266 | self.assertRaises(ValueError, rpc_interface.set_test_attribute, |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 267 | 'myattr', 'foo', test_name='mytest1') |
| 268 | |
| 269 | |
| 270 | def test_get_test_views(self): |
| 271 | tests = rpc_interface.get_test_views() |
| 272 | |
| 273 | self.assertEquals(len(tests), 3) |
| 274 | test = rpc_interface.get_test_views( |
| 275 | job_name='myjob1', test_name='mytest1')[0] |
| 276 | self.assertEquals(tests[0], test) |
| 277 | |
| 278 | self._check_for_get_test_views(test) |
| 279 | |
| 280 | self.assertEquals( |
| 281 | [], rpc_interface.get_test_views(hostname='fakehost')) |
| 282 | |
| 283 | |
showard | a5288b4 | 2009-07-28 20:06:08 +0000 | [diff] [blame] | 284 | def _check_test_names(self, tests, expected_names): |
| 285 | self.assertEquals(set(test['test_name'] for test in tests), |
| 286 | set(expected_names)) |
| 287 | |
| 288 | |
| 289 | def test_get_test_views_filter_on_labels(self): |
| 290 | tests = rpc_interface.get_test_views(include_labels=['testlabel1']) |
| 291 | self._check_test_names(tests, ['mytest1']) |
| 292 | |
| 293 | tests = rpc_interface.get_test_views(exclude_labels=['testlabel1']) |
| 294 | self._check_test_names(tests, ['mytest2', 'kernbench']) |
| 295 | |
| 296 | |
| 297 | def test_get_test_views_filter_on_attributes(self): |
| 298 | tests = rpc_interface.get_test_views( |
| 299 | include_attributes_where='attribute = "myattr" ' |
| 300 | 'and value = "myval"') |
| 301 | self._check_test_names(tests, ['mytest1']) |
| 302 | |
| 303 | tests = rpc_interface.get_test_views( |
| 304 | exclude_attributes_where='attribute="myattr2"') |
| 305 | self._check_test_names(tests, ['mytest2', 'kernbench']) |
| 306 | |
| 307 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 308 | def test_get_num_test_views(self): |
| 309 | self.assertEquals(rpc_interface.get_num_test_views(), 3) |
| 310 | self.assertEquals(rpc_interface.get_num_test_views( |
| 311 | job_name='myjob1', test_name='mytest1'), 1) |
| 312 | |
| 313 | |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 314 | def test_get_group_counts(self): |
showard | 06b82fc | 2009-06-30 01:59:42 +0000 | [diff] [blame] | 315 | self.assertEquals(rpc_interface.get_num_groups(['job_name']), 2) |
| 316 | |
| 317 | counts = rpc_interface.get_group_counts(['job_name']) |
| 318 | groups = counts['groups'] |
| 319 | self.assertEquals(len(groups), 2) |
| 320 | group1 = groups[0] |
| 321 | group2 = groups[1] |
| 322 | |
| 323 | self.assertEquals(group1['group_count'], 2) |
| 324 | self.assertEquals(group1['job_name'], 'myjob1') |
| 325 | self.assertEquals(group2['group_count'], 1) |
| 326 | self.assertEquals(group2['job_name'], 'myjob2') |
| 327 | |
| 328 | extra = {'extra' : 'kernel_hash'} |
| 329 | counts = rpc_interface.get_group_counts(['job_name'], |
| 330 | header_groups=[('job_name',)], |
| 331 | extra_select_fields=extra) |
| 332 | groups = counts['groups'] |
| 333 | self.assertEquals(len(groups), 2) |
| 334 | group1 = groups[0] |
| 335 | group2 = groups[1] |
| 336 | |
| 337 | self.assertEquals(group1['group_count'], 2) |
| 338 | self.assertEquals(group1['header_indices'], [0]) |
| 339 | self.assertEquals(group1['extra'], 'mykernel1') |
| 340 | self.assertEquals(group2['group_count'], 1) |
| 341 | self.assertEquals(group2['header_indices'], [1]) |
| 342 | self.assertEquals(group2['extra'], 'mykernel2') |
| 343 | |
| 344 | |
| 345 | def test_get_status_counts(self): |
| 346 | """\ |
| 347 | This method cannot be tested with a sqlite3 test framework. The method |
| 348 | relies on the IF function, which is not present in sqlite3. |
| 349 | """ |
| 350 | |
| 351 | |
| 352 | def test_get_latest_tests(self): |
| 353 | """\ |
| 354 | This method cannot be tested with a sqlite3 test framework. The method |
| 355 | relies on the IF function, which is not present in sqlite3. |
| 356 | """ |
| 357 | |
| 358 | |
| 359 | def test_get_job_ids(self): |
| 360 | self.assertEquals([1,2], rpc_interface.get_job_ids()) |
| 361 | self.assertEquals([1], rpc_interface.get_job_ids(test_name='mytest2')) |
| 362 | |
| 363 | |
| 364 | def test_get_hosts_and_tests(self): |
| 365 | host_info = rpc_interface.get_hosts_and_tests() |
| 366 | self.assertEquals(len(host_info), 1) |
| 367 | info = host_info['myhost'] |
| 368 | |
| 369 | self.assertEquals(info['tests'], ['kernbench']) |
| 370 | self.assertEquals(info['id'], 1) |
| 371 | |
| 372 | |
| 373 | def _check_for_get_test_labels(self, label, label_num): |
| 374 | self.assertEquals(label['id'], label_num) |
| 375 | self.assertEquals(label['description'], '') |
| 376 | self.assertEquals(label['name'], 'testlabel%d' % label_num) |
| 377 | |
| 378 | |
| 379 | def test_test_labels(self): |
| 380 | labels = rpc_interface.get_test_labels_for_tests(test_name='mytest1') |
| 381 | self.assertEquals(len(labels), 2) |
| 382 | label1 = labels[0] |
| 383 | label2 = labels[1] |
| 384 | |
| 385 | self._check_for_get_test_labels(label1, 1) |
| 386 | self._check_for_get_test_labels(label2, 2) |
| 387 | |
| 388 | rpc_interface.test_label_remove_tests(label1['id'], test_name='mytest1') |
| 389 | |
| 390 | labels = rpc_interface.get_test_labels_for_tests(test_name='mytest1') |
| 391 | self.assertEquals(len(labels), 1) |
| 392 | label = labels[0] |
| 393 | |
| 394 | self._check_for_get_test_labels(label, 2) |
| 395 | |
| 396 | rpc_interface.test_label_add_tests(label1['id'], test_name='mytest1') |
| 397 | |
| 398 | labels = rpc_interface.get_test_labels_for_tests(test_name='mytest1') |
| 399 | self.assertEquals(len(labels), 2) |
| 400 | label1 = labels[0] |
| 401 | label2 = labels[1] |
| 402 | |
| 403 | self._check_for_get_test_labels(label1, 1) |
| 404 | self._check_for_get_test_labels(label2, 2) |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 405 | |
| 406 | |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 407 | def test_get_test_attribute_fields(self): |
showard | 8bfb5cb | 2009-10-07 20:49:15 +0000 | [diff] [blame] | 408 | tests = rpc_interface.get_test_views( |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 409 | test_attribute_fields=['myattr', 'myattr2']) |
showard | 8bfb5cb | 2009-10-07 20:49:15 +0000 | [diff] [blame] | 410 | self.assertEquals(len(tests), 3) |
| 411 | |
| 412 | self.assertEquals(tests[0]['attribute_myattr'], 'myval') |
| 413 | self.assertEquals(tests[0]['attribute_myattr2'], 'myval2') |
| 414 | |
| 415 | for index in (1, 2): |
| 416 | self.assertEquals(tests[index]['attribute_myattr'], None) |
| 417 | self.assertEquals(tests[index]['attribute_myattr2'], None) |
| 418 | |
| 419 | |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 420 | def test_filtering_on_test_attribute_fields(self): |
| 421 | tests = rpc_interface.get_test_views( |
| 422 | extra_where='attribute_myattr.value = "myval"', |
| 423 | test_attribute_fields=['myattr']) |
| 424 | self.assertEquals(len(tests), 1) |
| 425 | |
| 426 | |
| 427 | def test_grouping_with_test_attribute_fields(self): |
| 428 | num_groups = rpc_interface.get_num_groups( |
| 429 | ['attribute_myattr'], test_attribute_fields=['myattr']) |
showard | d2b0c88 | 2009-10-19 18:34:11 +0000 | [diff] [blame] | 430 | self.assertEquals(num_groups, 2) |
| 431 | |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 432 | counts = rpc_interface.get_group_counts( |
| 433 | ['attribute_myattr'], test_attribute_fields=['myattr']) |
showard | 8bfb5cb | 2009-10-07 20:49:15 +0000 | [diff] [blame] | 434 | groups = counts['groups'] |
showard | d2b0c88 | 2009-10-19 18:34:11 +0000 | [diff] [blame] | 435 | self.assertEquals(len(groups), num_groups) |
showard | 8bfb5cb | 2009-10-07 20:49:15 +0000 | [diff] [blame] | 436 | self.assertEquals(groups[0]['attribute_myattr'], None) |
| 437 | self.assertEquals(groups[0]['group_count'], 2) |
| 438 | self.assertEquals(groups[1]['attribute_myattr'], 'myval') |
| 439 | self.assertEquals(groups[1]['group_count'], 1) |
| 440 | |
| 441 | |
showard | 8b0ea22 | 2009-12-23 19:23:03 +0000 | [diff] [blame] | 442 | def test_get_test_label_fields(self): |
| 443 | tests = rpc_interface.get_test_views( |
| 444 | test_label_fields=['testlabel1', 'testlabel2']) |
| 445 | self.assertEquals(len(tests), 3) |
| 446 | |
| 447 | self.assertEquals(tests[0]['label_testlabel1'], 'testlabel1') |
| 448 | self.assert_(tests[0]['label_testlabel2'], 'testlabel2') |
| 449 | |
| 450 | for index in (1, 2): |
| 451 | self.assertEquals(tests[index]['label_testlabel1'], None) |
| 452 | self.assertEquals(tests[index]['label_testlabel2'], None) |
| 453 | |
| 454 | |
| 455 | def test_filtering_on_test_label_fields(self): |
| 456 | tests = rpc_interface.get_test_views( |
| 457 | extra_where='label_testlabel1 = "testlabel1"', |
| 458 | test_label_fields=['testlabel1']) |
| 459 | self.assertEquals(len(tests), 1) |
| 460 | |
| 461 | |
| 462 | def test_grouping_on_test_label_fields(self): |
| 463 | num_groups = rpc_interface.get_num_groups( |
| 464 | ['label_testlabel1'], test_label_fields=['testlabel1']) |
| 465 | self.assertEquals(num_groups, 2) |
| 466 | |
| 467 | counts = rpc_interface.get_group_counts( |
| 468 | ['label_testlabel1'], test_label_fields=['testlabel1']) |
| 469 | groups = counts['groups'] |
| 470 | self.assertEquals(len(groups), 2) |
| 471 | self.assertEquals(groups[0]['label_testlabel1'], None) |
| 472 | self.assertEquals(groups[0]['group_count'], 2) |
| 473 | self.assertEquals(groups[1]['label_testlabel1'], 'testlabel1') |
| 474 | self.assertEquals(groups[1]['group_count'], 1) |
| 475 | |
| 476 | |
| 477 | def test_get_iteration_fields(self): |
| 478 | num_iterations = rpc_interface.get_num_test_views( |
| 479 | iteration_fields=['iresult', 'iresult2']) |
| 480 | self.assertEquals(num_iterations, 2) |
| 481 | |
| 482 | iterations = rpc_interface.get_test_views( |
| 483 | iteration_fields=['iresult', 'iresult2']) |
| 484 | self.assertEquals(len(iterations), 2) |
| 485 | |
| 486 | for index in (0, 1): |
| 487 | self.assertEquals(iterations[index]['test_idx'], 1) |
| 488 | |
| 489 | self.assertEquals(iterations[0]['iteration_index'], 1) |
| 490 | self.assertEquals(iterations[0]['iteration_iresult'], 1) |
| 491 | self.assertEquals(iterations[0]['iteration_iresult2'], 2) |
| 492 | |
| 493 | self.assertEquals(iterations[1]['iteration_index'], 2) |
| 494 | self.assertEquals(iterations[1]['iteration_iresult'], 3) |
| 495 | self.assertEquals(iterations[1]['iteration_iresult2'], 4) |
| 496 | |
| 497 | |
| 498 | def test_filtering_on_iteration_fields(self): |
| 499 | iterations = rpc_interface.get_test_views( |
| 500 | extra_where='iteration_iresult.value = 1', |
| 501 | iteration_fields=['iresult']) |
| 502 | self.assertEquals(len(iterations), 1) |
| 503 | |
| 504 | |
| 505 | def test_grouping_with_iteration_fields(self): |
| 506 | num_groups = rpc_interface.get_num_groups(['iteration_iresult'], |
| 507 | iteration_fields=['iresult']) |
| 508 | self.assertEquals(num_groups, 2) |
| 509 | |
| 510 | counts = rpc_interface.get_group_counts(['iteration_iresult'], |
| 511 | iteration_fields=['iresult']) |
| 512 | groups = counts['groups'] |
| 513 | self.assertEquals(len(groups), 2) |
| 514 | self.assertEquals(groups[0]['iteration_iresult'], 1) |
| 515 | self.assertEquals(groups[0]['group_count'], 1) |
| 516 | self.assertEquals(groups[1]['iteration_iresult'], 3) |
| 517 | self.assertEquals(groups[1]['group_count'], 1) |
| 518 | |
| 519 | |
| 520 | def _setup_machine_labels(self): |
| 521 | models.TestAttribute.objects.create(test=self.first_test, |
| 522 | attribute='host-labels', |
| 523 | value='label1,label2') |
| 524 | |
| 525 | |
| 526 | def test_get_machine_label_fields(self): |
| 527 | self._setup_machine_labels() |
| 528 | |
| 529 | tests = rpc_interface.get_test_views( |
| 530 | machine_label_fields=['label1', 'otherlabel']) |
| 531 | self.assertEquals(len(tests), 3) |
| 532 | |
| 533 | self.assertEquals(tests[0]['machine_label_label1'], 'label1') |
| 534 | self.assertEquals(tests[0]['machine_label_otherlabel'], None) |
| 535 | |
| 536 | for index in (1, 2): |
| 537 | self.assertEquals(tests[index]['machine_label_label1'], None) |
| 538 | self.assertEquals(tests[index]['machine_label_otherlabel'], None) |
| 539 | |
| 540 | |
| 541 | def test_grouping_with_machine_label_fields(self): |
| 542 | self._setup_machine_labels() |
| 543 | |
| 544 | counts = rpc_interface.get_group_counts(['machine_label_label1'], |
| 545 | machine_label_fields=['label1']) |
| 546 | groups = counts['groups'] |
| 547 | self.assertEquals(len(groups), 2) |
| 548 | self.assertEquals(groups[0]['machine_label_label1'], None) |
| 549 | self.assertEquals(groups[0]['group_count'], 2) |
| 550 | self.assertEquals(groups[1]['machine_label_label1'], 'label1') |
| 551 | self.assertEquals(groups[1]['group_count'], 1) |
| 552 | |
| 553 | |
| 554 | def test_filtering_on_machine_label_fields(self): |
| 555 | self._setup_machine_labels() |
| 556 | |
| 557 | tests = rpc_interface.get_test_views( |
| 558 | extra_where='machine_label_label1 = "label1"', |
| 559 | machine_label_fields=['label1']) |
| 560 | self.assertEquals(len(tests), 1) |
| 561 | |
| 562 | |
| 563 | def test_quoting_fields(self): |
| 564 | # ensure fields with special characters are properly quoted throughout |
| 565 | rpc_interface.add_test_label('hyphen-label') |
| 566 | rpc_interface.get_group_counts( |
| 567 | ['attribute_hyphen-attr', 'label_hyphen-label', |
| 568 | 'machine_label_hyphen-label', 'iteration_hyphen-result'], |
| 569 | test_attribute_fields=['hyphen-attr'], |
| 570 | test_label_fields=['hyphen-label'], |
| 571 | machine_label_fields=['hyphen-label'], |
| 572 | iteration_fields=['hyphen-result']) |
| 573 | |
| 574 | |
showard | f8b1904 | 2009-05-12 17:22:49 +0000 | [diff] [blame] | 575 | if __name__ == '__main__': |
| 576 | unittest.main() |