OLD | NEW |
(Empty) | |
| 1 # Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 # Use of this source code is govered by a BSD-style |
| 3 # license that can be found in the LICENSE file or at |
| 4 # https://developers.google.com/open-source/licenses/bsd |
| 5 |
| 6 """Unit tests for table_view_helpers classes and functions.""" |
| 7 |
| 8 import collections |
| 9 import unittest |
| 10 |
| 11 from framework import framework_views |
| 12 from framework import table_view_helpers |
| 13 from proto import tracker_pb2 |
| 14 from testing import fake |
| 15 from tracker import tracker_bizobj |
| 16 |
| 17 |
| 18 EMPTY_SEARCH_RESULTS = [] |
| 19 |
| 20 SEARCH_RESULTS_WITH_LABELS = [ |
| 21 fake.MakeTestIssue( |
| 22 789, 1, 'sum 1', 'New', 111L, labels='Priority-High Mstone-1', |
| 23 merged_into=200001, star_count=1), |
| 24 fake.MakeTestIssue( |
| 25 789, 2, 'sum 2', 'New', 111L, labels='Priority-High Mstone-1', |
| 26 merged_into=1, star_count=1), |
| 27 fake.MakeTestIssue( |
| 28 789, 3, 'sum 3', 'New', 111L, labels='Priority-Low Mstone-1.1', |
| 29 merged_into=1, star_count=1), |
| 30 # 'Visibility-Super-High' tests that only first dash counts |
| 31 fake.MakeTestIssue( |
| 32 789, 4, 'sum 4', 'New', 111L, labels='Visibility-Super-High', |
| 33 star_count=1), |
| 34 ] |
| 35 |
| 36 |
| 37 def MakeTestIssue(local_id, issue_id, summary): |
| 38 issue = tracker_pb2.Issue() |
| 39 issue.local_id = local_id |
| 40 issue.issue_id = issue_id |
| 41 issue.summary = summary |
| 42 return issue |
| 43 |
| 44 |
| 45 class TableCellTest(unittest.TestCase): |
| 46 |
| 47 USERS_BY_ID = {} |
| 48 |
| 49 def setUp(self): |
| 50 self.issue1 = MakeTestIssue( |
| 51 local_id=1, issue_id=100001, summary='One') |
| 52 self.issue2 = MakeTestIssue( |
| 53 local_id=2, issue_id=100002, summary='Two') |
| 54 self.issue3 = MakeTestIssue( |
| 55 local_id=3, issue_id=100003, summary='Three') |
| 56 |
| 57 def testTableCellSummary(self): |
| 58 """TableCellSummary stores the data given to it.""" |
| 59 cell = table_view_helpers.TableCellSummary( |
| 60 MakeTestIssue(4, 4, 'Lame default summary.'), None, self.USERS_BY_ID, |
| 61 [('lab', False)], {}, {}, 'fake config') |
| 62 self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_SUMMARY) |
| 63 self.assertEqual(cell.values[0].item, 'Lame default summary.') |
| 64 self.assertEqual(cell.non_column_labels[0].value, 'lab') |
| 65 |
| 66 def testTableCellSummary_NoPythonEscaping(self): |
| 67 """TableCellSummary stores the summary without escaping it in python.""" |
| 68 cell = table_view_helpers.TableCellSummary( |
| 69 MakeTestIssue(4, 4, '<b>bold</b> "summary".'), None, self.USERS_BY_ID, |
| 70 [('lab', False)], {}, {}, 'fake config') |
| 71 self.assertEqual(cell.values[0].item,'<b>bold</b> "summary".') |
| 72 |
| 73 # TODO(jrobbins): TableCellProject, TableCellStars |
| 74 |
| 75 |
| 76 class TableViewHelpersTest(unittest.TestCase): |
| 77 |
| 78 def setUp(self): |
| 79 self.default_cols = 'a b c' |
| 80 self.builtin_cols = ['a', 'b', 'x', 'y', 'z'] |
| 81 self.config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 82 |
| 83 def testComputeUnshownColumns_CommonCase(self): |
| 84 shown_cols = ['a', 'b', 'c'] |
| 85 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 86 config.default_col_spec = self.default_cols |
| 87 config.well_known_labels = [] |
| 88 |
| 89 unshown = table_view_helpers.ComputeUnshownColumns( |
| 90 EMPTY_SEARCH_RESULTS, shown_cols, config, self.builtin_cols) |
| 91 self.assertEquals(unshown, ['x', 'y', 'z']) |
| 92 |
| 93 unshown = table_view_helpers.ComputeUnshownColumns( |
| 94 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, self.builtin_cols) |
| 95 self.assertEquals( |
| 96 unshown, ['Mstone', 'Priority', 'Visibility', 'x', 'y', 'z']) |
| 97 |
| 98 def testComputeUnshownColumns_MoreBuiltins(self): |
| 99 shown_cols = ['a', 'b', 'c', 'x', 'y'] |
| 100 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 101 config.default_col_spec = self.default_cols |
| 102 config.well_known_labels = [] |
| 103 |
| 104 unshown = table_view_helpers.ComputeUnshownColumns( |
| 105 EMPTY_SEARCH_RESULTS, shown_cols, config, self.builtin_cols) |
| 106 self.assertEquals(unshown, ['z']) |
| 107 |
| 108 unshown = table_view_helpers.ComputeUnshownColumns( |
| 109 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, self.builtin_cols) |
| 110 self.assertEquals(unshown, ['Mstone', 'Priority', 'Visibility', 'z']) |
| 111 |
| 112 def testComputeUnshownColumns_NotAllDefaults(self): |
| 113 shown_cols = ['a', 'b'] |
| 114 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 115 config.default_col_spec = self.default_cols |
| 116 config.well_known_labels = [] |
| 117 |
| 118 unshown = table_view_helpers.ComputeUnshownColumns( |
| 119 EMPTY_SEARCH_RESULTS, shown_cols, config, self.builtin_cols) |
| 120 self.assertEquals(unshown, ['c', 'x', 'y', 'z']) |
| 121 |
| 122 unshown = table_view_helpers.ComputeUnshownColumns( |
| 123 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, self.builtin_cols) |
| 124 self.assertEquals( |
| 125 unshown, ['Mstone', 'Priority', 'Visibility', 'c', 'x', 'y', 'z']) |
| 126 |
| 127 def testComputeUnshownColumns_ExtraNonDefaults(self): |
| 128 shown_cols = ['a', 'b', 'c', 'd', 'e', 'f'] |
| 129 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 130 config.default_col_spec = self.default_cols |
| 131 config.well_known_labels = [] |
| 132 |
| 133 unshown = table_view_helpers.ComputeUnshownColumns( |
| 134 EMPTY_SEARCH_RESULTS, shown_cols, config, self.builtin_cols) |
| 135 self.assertEquals(unshown, ['x', 'y', 'z']) |
| 136 |
| 137 unshown = table_view_helpers.ComputeUnshownColumns( |
| 138 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, self.builtin_cols) |
| 139 self.assertEquals( |
| 140 unshown, ['Mstone', 'Priority', 'Visibility', 'x', 'y', 'z']) |
| 141 |
| 142 def testComputeUnshownColumns_UserColumnsShown(self): |
| 143 shown_cols = ['a', 'b', 'c', 'Priority'] |
| 144 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 145 config.default_col_spec = self.default_cols |
| 146 config.well_known_labels = [] |
| 147 |
| 148 unshown = table_view_helpers.ComputeUnshownColumns( |
| 149 EMPTY_SEARCH_RESULTS, shown_cols, config, self.builtin_cols) |
| 150 self.assertEquals(unshown, ['x', 'y', 'z']) |
| 151 |
| 152 unshown = table_view_helpers.ComputeUnshownColumns( |
| 153 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, self.builtin_cols) |
| 154 self.assertEquals(unshown, ['Mstone', 'Visibility', 'x', 'y', 'z']) |
| 155 |
| 156 def testComputeUnshownColumns_EverythingShown(self): |
| 157 shown_cols = [ |
| 158 'a', 'b', 'c', 'x', 'y', 'z', 'Priority', 'Mstone', 'Visibility'] |
| 159 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 160 config.default_col_spec = self.default_cols |
| 161 config.well_known_labels = [] |
| 162 |
| 163 unshown = table_view_helpers.ComputeUnshownColumns( |
| 164 EMPTY_SEARCH_RESULTS, shown_cols, config, self.builtin_cols) |
| 165 self.assertEquals(unshown, []) |
| 166 |
| 167 unshown = table_view_helpers.ComputeUnshownColumns( |
| 168 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, self.builtin_cols) |
| 169 self.assertEquals(unshown, []) |
| 170 |
| 171 def testComputeUnshownColumns_NothingShown(self): |
| 172 shown_cols = [] |
| 173 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 174 config.default_col_spec = self.default_cols |
| 175 config.well_known_labels = [] |
| 176 |
| 177 unshown = table_view_helpers.ComputeUnshownColumns( |
| 178 EMPTY_SEARCH_RESULTS, shown_cols, config, self.builtin_cols) |
| 179 self.assertEquals(unshown, ['a', 'b', 'c', 'x', 'y', 'z']) |
| 180 |
| 181 unshown = table_view_helpers.ComputeUnshownColumns( |
| 182 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, self.builtin_cols) |
| 183 self.assertEquals( |
| 184 unshown, |
| 185 ['Mstone', 'Priority', 'Visibility', 'a', 'b', 'c', 'x', 'y', 'z']) |
| 186 |
| 187 def testComputeUnshownColumns_NoBuiltins(self): |
| 188 shown_cols = ['a', 'b', 'c'] |
| 189 config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| 190 config.default_col_spec = 'a b c' |
| 191 config.well_known_labels = [] |
| 192 builtin_cols = [] |
| 193 |
| 194 unshown = table_view_helpers.ComputeUnshownColumns( |
| 195 EMPTY_SEARCH_RESULTS, shown_cols, config, builtin_cols) |
| 196 self.assertEquals(unshown, []) |
| 197 |
| 198 unshown = table_view_helpers.ComputeUnshownColumns( |
| 199 SEARCH_RESULTS_WITH_LABELS, shown_cols, config, builtin_cols) |
| 200 self.assertEquals(unshown, ['Mstone', 'Priority', 'Visibility']) |
| 201 |
| 202 def testExtractUniqueValues_NoColumns(self): |
| 203 column_values = table_view_helpers.ExtractUniqueValues( |
| 204 [], SEARCH_RESULTS_WITH_LABELS, {}, self.config) |
| 205 self.assertEquals([], column_values) |
| 206 |
| 207 def testExtractUniqueValues_NoResults(self): |
| 208 cols = ['type', 'priority', 'owner', 'status', 'stars', 'attachments'] |
| 209 column_values = table_view_helpers.ExtractUniqueValues( |
| 210 cols, EMPTY_SEARCH_RESULTS, {}, self.config) |
| 211 self.assertEquals(6, len(column_values)) |
| 212 for index, col in enumerate(cols): |
| 213 self.assertEquals(index, column_values[index].col_index) |
| 214 self.assertEquals(col, column_values[index].column_name) |
| 215 self.assertEquals([], column_values[index].filter_values) |
| 216 |
| 217 def testExtractUniqueValues_ExplicitResults(self): |
| 218 cols = ['priority', 'owner', 'status', 'stars', 'mstone', 'foo'] |
| 219 users_by_id = { |
| 220 111L: framework_views.UserView(111, 'foo@example.com', True), |
| 221 } |
| 222 column_values = table_view_helpers.ExtractUniqueValues( |
| 223 cols, SEARCH_RESULTS_WITH_LABELS, users_by_id, self.config) |
| 224 self.assertEquals(len(cols), len(column_values)) |
| 225 |
| 226 self.assertEquals('priority', column_values[0].column_name) |
| 227 self.assertEquals(['High', 'Low'], column_values[0].filter_values) |
| 228 |
| 229 self.assertEquals('owner', column_values[1].column_name) |
| 230 self.assertEquals(['f...@example.com'], column_values[1].filter_values) |
| 231 |
| 232 self.assertEquals('status', column_values[2].column_name) |
| 233 self.assertEquals(['New'], column_values[2].filter_values) |
| 234 |
| 235 self.assertEquals('stars', column_values[3].column_name) |
| 236 self.assertEquals([1], column_values[3].filter_values) |
| 237 |
| 238 self.assertEquals('mstone', column_values[4].column_name) |
| 239 self.assertEquals(['1', '1.1'], column_values[4].filter_values) |
| 240 |
| 241 self.assertEquals('foo', column_values[5].column_name) |
| 242 self.assertEquals([], column_values[5].filter_values) |
| 243 |
| 244 # self.assertEquals('mergedinto', column_values[6].column_name) |
| 245 # self.assertEquals( |
| 246 # ['1', 'other-project:1'], column_values[6].filter_values) |
| 247 |
| 248 def testExtractUniqueValues_CombinedColumns(self): |
| 249 cols = ['priority/pri', 'owner', 'status', 'stars', 'mstone/milestone'] |
| 250 users_by_id = { |
| 251 111L: framework_views.UserView(111, 'foo@example.com', True), |
| 252 } |
| 253 issue = fake.MakeTestIssue( |
| 254 789, 5, 'sum 5', 'New', 111L, merged_into=200001, |
| 255 labels='Priority-High Pri-0 Milestone-1.0 mstone-1', |
| 256 star_count=15) |
| 257 |
| 258 column_values = table_view_helpers.ExtractUniqueValues( |
| 259 cols, SEARCH_RESULTS_WITH_LABELS + [issue], users_by_id, |
| 260 self.config) |
| 261 self.assertEquals(5, len(column_values)) |
| 262 |
| 263 self.assertEquals('priority/pri', column_values[0].column_name) |
| 264 self.assertEquals(['0', 'High', 'Low'], column_values[0].filter_values) |
| 265 |
| 266 self.assertEquals('owner', column_values[1].column_name) |
| 267 self.assertEquals(['f...@example.com'], column_values[1].filter_values) |
| 268 |
| 269 self.assertEquals('status', column_values[2].column_name) |
| 270 self.assertEquals(['New'], column_values[2].filter_values) |
| 271 |
| 272 self.assertEquals('stars', column_values[3].column_name) |
| 273 self.assertEquals([1, 15], column_values[3].filter_values) |
| 274 |
| 275 self.assertEquals('mstone/milestone', column_values[4].column_name) |
| 276 self.assertEquals(['1', '1.0', '1.1'], column_values[4].filter_values) |
| 277 |
| 278 def testExtractUniqueValues_DerivedValues(self): |
| 279 cols = ['priority', 'milestone', 'owner', 'status'] |
| 280 users_by_id = { |
| 281 111L: framework_views.UserView(111, 'foo@example.com', True), |
| 282 222L: framework_views.UserView(222, 'bar@example.com', True), |
| 283 333L: framework_views.UserView(333, 'lol@example.com', True), |
| 284 } |
| 285 search_results = [ |
| 286 fake.MakeTestIssue( |
| 287 789, 1, 'sum 1', '', 111L, labels='Priority-High Milestone-1.0', |
| 288 derived_labels='Milestone-2.0 Foo', derived_status='Started'), |
| 289 fake.MakeTestIssue( |
| 290 789, 2, 'sum 2', 'New', 111L, labels='Priority-High Milestone-1.0', |
| 291 derived_owner_id=333L), # Not seen because of owner_id |
| 292 fake.MakeTestIssue( |
| 293 789, 3, 'sum 3', 'New', 0, labels='Priority-Low Milestone-1.1', |
| 294 derived_owner_id=222L), |
| 295 ] |
| 296 |
| 297 column_values = table_view_helpers.ExtractUniqueValues( |
| 298 cols, search_results, users_by_id, self.config) |
| 299 self.assertEquals(4, len(column_values)) |
| 300 |
| 301 self.assertEquals('priority', column_values[0].column_name) |
| 302 self.assertEquals(['High', 'Low'], column_values[0].filter_values) |
| 303 |
| 304 self.assertEquals('milestone', column_values[1].column_name) |
| 305 self.assertEquals(['1.0', '1.1', '2.0'], |
| 306 column_values[1].filter_values) |
| 307 |
| 308 self.assertEquals('owner', column_values[2].column_name) |
| 309 self.assertEquals(['b...@example.com', 'f...@example.com'], |
| 310 column_values[2].filter_values) |
| 311 |
| 312 self.assertEquals('status', column_values[3].column_name) |
| 313 self.assertEquals(['New', 'Started'], column_values[3].filter_values) |
| 314 |
| 315 def testExtractUniqueValues_ColumnsRobustness(self): |
| 316 cols = ['reporter', 'cc', 'owner', 'status', 'attachments'] |
| 317 search_results = [ |
| 318 tracker_pb2.Issue(), |
| 319 ] |
| 320 column_values = table_view_helpers.ExtractUniqueValues( |
| 321 cols, search_results, {}, self.config) |
| 322 |
| 323 self.assertEquals(5, len(column_values)) |
| 324 for col_val in column_values: |
| 325 if col_val.column_name == 'attachments': |
| 326 self.assertEquals([0], col_val.filter_values) |
| 327 else: |
| 328 self.assertEquals([], col_val.filter_values) |
| 329 |
| 330 def testMakeTableData_Empty(self): |
| 331 visible_results = [] |
| 332 lower_columns = [] |
| 333 cell_factories = {} |
| 334 table_data = table_view_helpers.MakeTableData( |
| 335 visible_results, None, [], lower_columns, lower_columns, |
| 336 cell_factories, [], lambda art: 'id', {}, self.config) |
| 337 self.assertEqual([], table_data) |
| 338 |
| 339 lower_columns = ['type', 'priority', 'summary', 'stars'] |
| 340 cell_factories = { |
| 341 'summary': table_view_helpers.TableCellSummary, |
| 342 'stars': table_view_helpers.TableCellStars, |
| 343 } |
| 344 |
| 345 table_data = table_view_helpers.MakeTableData( |
| 346 visible_results, None, [], lower_columns, [], {}, |
| 347 cell_factories, lambda art: 'id', {}, self.config) |
| 348 self.assertEqual([], table_data) |
| 349 |
| 350 def testMakeTableData_Normal(self): |
| 351 art = fake.MakeTestIssue( |
| 352 789, 1, 'sum 1', 'New', 111L, labels='Type-Defect Priority-Medium') |
| 353 visible_results = [art] |
| 354 lower_columns = ['type', 'priority', 'summary', 'stars'] |
| 355 cell_factories = { |
| 356 'summary': table_view_helpers.TableCellSummary, |
| 357 'stars': table_view_helpers.TableCellStars, |
| 358 } |
| 359 |
| 360 table_data = table_view_helpers.MakeTableData( |
| 361 visible_results, None, [], lower_columns, lower_columns, {}, |
| 362 cell_factories, lambda art: 'id', {}, self.config) |
| 363 self.assertEqual(1, len(table_data)) |
| 364 row = table_data[0] |
| 365 self.assertEqual(4, len(row.cells)) |
| 366 self.assertEqual('Defect', row.cells[0].values[0].item) |
| 367 |
| 368 def testMakeTableData_Groups(self): |
| 369 art = fake.MakeTestIssue( |
| 370 789, 1, 'sum 1', 'New', 111L, labels='Type-Defect Priority-Medium') |
| 371 visible_results = [art] |
| 372 lower_columns = ['type', 'priority', 'summary', 'stars'] |
| 373 lower_group_by = ['priority'] |
| 374 cell_factories = { |
| 375 'summary': table_view_helpers.TableCellSummary, |
| 376 'stars': table_view_helpers.TableCellStars, |
| 377 } |
| 378 |
| 379 table_data = table_view_helpers.MakeTableData( |
| 380 visible_results, None, [], lower_columns, lower_group_by, {}, |
| 381 cell_factories, lambda art: 'id', {}, self.config) |
| 382 self.assertEqual(1, len(table_data)) |
| 383 row = table_data[0] |
| 384 self.assertEqual(1, len(row.group.cells)) |
| 385 self.assertEqual('Medium', row.group.cells[0].values[0].item) |
| 386 |
| 387 def testMakeRowData(self): |
| 388 art = fake.MakeTestIssue( |
| 389 789, 1, 'sum 1', 'New', 111L, labels='Type-Defect Priority-Medium', |
| 390 star_count=1) |
| 391 columns = ['type', 'priority', 'summary', 'stars'] |
| 392 |
| 393 cell_factories = [table_view_helpers.TableCellKeyLabels, |
| 394 table_view_helpers.TableCellKeyLabels, |
| 395 table_view_helpers.TableCellSummary, |
| 396 table_view_helpers.TableCellStars] |
| 397 |
| 398 # a result is an table_view_helpers.TableRow object with a "cells" field |
| 399 # containing a list of table_view_helpers.TableCell objects. |
| 400 result = table_view_helpers.MakeRowData( |
| 401 art, columns, True, {}, cell_factories, {}, self.config) |
| 402 |
| 403 self.assertEqual(len(columns), len(result.cells)) |
| 404 |
| 405 for i in range(len(columns)): |
| 406 cell = result.cells[i] |
| 407 self.assertEqual(i, cell.col_index) |
| 408 |
| 409 self.assertEqual(table_view_helpers.CELL_TYPE_ATTR, result.cells[0].type) |
| 410 self.assertEqual('Defect', result.cells[0].values[0].item) |
| 411 self.assertFalse(result.cells[0].values[0].is_derived) |
| 412 |
| 413 self.assertEqual(table_view_helpers.CELL_TYPE_ATTR, result.cells[1].type) |
| 414 self.assertEqual('Medium', result.cells[1].values[0].item) |
| 415 self.assertFalse(result.cells[1].values[0].is_derived) |
| 416 |
| 417 self.assertEqual( |
| 418 table_view_helpers.CELL_TYPE_SUMMARY, result.cells[2].type) |
| 419 self.assertEqual('sum 1', result.cells[2].values[0].item) |
| 420 self.assertFalse(result.cells[2].values[0].is_derived) |
| 421 |
| 422 self.assertEqual(table_view_helpers.CELL_TYPE_ATTR, result.cells[3].type) |
| 423 self.assertEqual(1, result.cells[3].values[0].item) |
| 424 self.assertFalse(result.cells[3].values[0].is_derived) |
| 425 |
| 426 def testAccumulateLabelValues_Empty(self): |
| 427 label_values, non_col_labels = collections.defaultdict(list), [] |
| 428 table_view_helpers._AccumulateLabelValues( |
| 429 [], [], label_values, non_col_labels) |
| 430 self.assertEqual({}, label_values) |
| 431 self.assertEqual([], non_col_labels) |
| 432 |
| 433 label_values, non_col_labels = collections.defaultdict(list), [] |
| 434 table_view_helpers._AccumulateLabelValues( |
| 435 [], ['Type', 'Priority'], label_values, non_col_labels) |
| 436 self.assertEqual({}, label_values) |
| 437 self.assertEqual([], non_col_labels) |
| 438 |
| 439 def testAccumulateLabelValues_OneWordLabels(self): |
| 440 label_values, non_col_labels = collections.defaultdict(list), [] |
| 441 table_view_helpers._AccumulateLabelValues( |
| 442 ['HelloThere'], [], label_values, non_col_labels) |
| 443 self.assertEqual({}, label_values) |
| 444 self.assertEqual([('HelloThere', False)], non_col_labels) |
| 445 |
| 446 label_values, non_col_labels = collections.defaultdict(list), [] |
| 447 table_view_helpers._AccumulateLabelValues( |
| 448 ['HelloThere'], [], label_values, non_col_labels, is_derived=True) |
| 449 self.assertEqual({}, label_values) |
| 450 self.assertEqual([('HelloThere', True)], non_col_labels) |
| 451 |
| 452 def testAccumulateLabelValues_KeyValueLabels(self): |
| 453 label_values, non_col_labels = collections.defaultdict(list), [] |
| 454 table_view_helpers._AccumulateLabelValues( |
| 455 ['Type-Defect', 'Milestone-Soon'], ['type', 'milestone'], |
| 456 label_values, non_col_labels) |
| 457 self.assertEqual( |
| 458 {'type': [('Defect', False)], |
| 459 'milestone': [('Soon', False)]}, |
| 460 label_values) |
| 461 self.assertEqual([], non_col_labels) |
| 462 |
| 463 def testAccumulateLabelValues_MultiValueLabels(self): |
| 464 label_values, non_col_labels = collections.defaultdict(list), [] |
| 465 table_view_helpers._AccumulateLabelValues( |
| 466 ['OS-Mac', 'OS-Linux'], ['os', 'arch'], |
| 467 label_values, non_col_labels) |
| 468 self.assertEqual( |
| 469 {'os': [('Mac', False), ('Linux', False)]}, |
| 470 label_values) |
| 471 self.assertEqual([], non_col_labels) |
| 472 |
| 473 def testAccumulateLabelValues_MultiPartLabels(self): |
| 474 label_values, non_col_labels = collections.defaultdict(list), [] |
| 475 table_view_helpers._AccumulateLabelValues( |
| 476 ['OS-Mac-Server', 'OS-Mac-Laptop'], ['os', 'os-mac'], |
| 477 label_values, non_col_labels) |
| 478 self.assertEqual( |
| 479 {'os': [('Mac-Server', False), ('Mac-Laptop', False)], |
| 480 'os-mac': [('Server', False), ('Laptop', False)], |
| 481 }, |
| 482 label_values) |
| 483 self.assertEqual([], non_col_labels) |
| 484 |
| 485 |
| 486 if __name__ == '__main__': |
| 487 unittest.main() |
OLD | NEW |