| # Copyright 2016 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unit tests for issuelist module.""" |
| from __future__ import print_function |
| from __future__ import division |
| from __future__ import absolute_import |
| |
| import time |
| import unittest |
| |
| from framework import framework_constants |
| from framework import table_view_helpers |
| from framework import template_helpers |
| from mrproto import tracker_pb2 |
| from testing import fake |
| from testing import testing_helpers |
| from tracker import tablecell |
| from tracker import tracker_bizobj |
| |
| |
| class DisplayNameMock(object): |
| |
| def __init__(self, name): |
| self.display_name = name |
| self.user = None |
| |
| |
| def MakeTestIssue(local_id, issue_id, summary, status=None): |
| issue = tracker_pb2.Issue() |
| issue.local_id = local_id |
| issue.issue_id = issue_id |
| issue.summary = summary |
| if status: |
| issue.status = status |
| return issue |
| |
| |
| class TableCellUnitTest(unittest.TestCase): |
| |
| USERS_BY_ID = { |
| 23456: DisplayNameMock('Jason'), |
| 34567: DisplayNameMock('Nathan'), |
| } |
| |
| def setUp(self): |
| self.issue1 = MakeTestIssue( |
| local_id=1, issue_id=100001, summary='One', status="New") |
| self.issue2 = MakeTestIssue( |
| local_id=2, issue_id=100002, summary='Two', status="Fixed") |
| self.issue3 = MakeTestIssue( |
| local_id=3, issue_id=100003, summary='Three', status="UndefinedString") |
| self.issue5 = MakeTestIssue( |
| local_id=5, issue_id=100005, summary='FiveUnviewable', status="Fixed") |
| self.table_cell_kws = { |
| 'col': None, |
| 'users_by_id': self.USERS_BY_ID, |
| 'non_col_labels': [], |
| 'label_values': {}, |
| 'related_issues': {}, |
| 'config': tracker_bizobj.MakeDefaultProjectIssueConfig(678), |
| 'viewable_iids_set': {100001, 100002, 100003} |
| } |
| |
| def testTableCellNote(self): |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws.update({'note': ''}) |
| cell = tablecell.TableCellNote( |
| self.issue1, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_NOTE) |
| self.assertEqual(cell.values, []) |
| |
| def testTableCellNote_NoNote(self): |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws.update({'note': 'some note'}) |
| cell = tablecell.TableCellNote( |
| self.issue1, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_NOTE) |
| self.assertEqual(cell.values[0].item, 'some note') |
| |
| def testTableCellDateAdded(self): |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws.update({'date_added': 1234}) |
| cell = tablecell.TableCellDateAdded( |
| self.issue1, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 1234) |
| |
| def testTableCellAdderID(self): |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws.update({'adder_id': 23456}) |
| cell = tablecell.TableCellAdderID( |
| self.issue1, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 'Jason') |
| |
| def testTableCellRank(self): |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws.update({'issue_rank': 3}) |
| cell = tablecell.TableCellRank( |
| self.issue1, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 3) |
| |
| def testTableCellID(self): |
| cell = tablecell.TableCellID( |
| MakeTestIssue(4, 4, 'Four'), **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ID) |
| # Note that the ID itself is accessed from the row, not the cell. |
| |
| def testTableCellOwner(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.owner_id=23456 |
| |
| cell = tablecell.TableCellOwner( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 'Jason') |
| |
| def testTableCellOwnerNoOwner(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.owner_id=framework_constants.NO_USER_SPECIFIED |
| |
| cell = tablecell.TableCellOwner( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values, []) |
| |
| def testTableCellReporter(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.reporter_id=34567 |
| |
| cell = tablecell.TableCellReporter( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 'Nathan') |
| |
| def testTableCellCc(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.cc_ids = [23456, 34567] |
| |
| cell = tablecell.TableCellCc( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 'Jason') |
| self.assertEqual(cell.values[1].item, 'Nathan') |
| |
| def testTableCellCcNoCcs(self): |
| cell = tablecell.TableCellCc( |
| MakeTestIssue(4, 4, 'Four'), **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values, []) |
| |
| def testTableCellAttachmentsNone(self): |
| cell = tablecell.TableCellAttachments( |
| MakeTestIssue(4, 4, 'Four'), **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 0) |
| |
| def testTableCellAttachments(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.attachment_count = 2 |
| |
| cell = tablecell.TableCellAttachments( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 2) |
| |
| def testTableCellOpened(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.opened_timestamp = 1200000000 |
| |
| cell = tablecell.TableCellOpened( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 'Jan 2008') |
| |
| def testTableCellClosed(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.closed_timestamp = None |
| |
| cell = tablecell.TableCellClosed( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values, []) |
| |
| test_issue.closed_timestamp = 1200000000 |
| cell = tablecell.TableCellClosed( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 'Jan 2008') |
| |
| def testTableCellModified(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.modified_timestamp = None |
| |
| cell = tablecell.TableCellModified( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values, []) |
| |
| test_issue.modified_timestamp = 1200000000 |
| cell = tablecell.TableCellModified( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 'Jan 2008') |
| |
| def testTableCellOwnerLastVisit(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.owner_id = None |
| |
| cell = tablecell.TableCellOwnerLastVisit( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values, []) |
| |
| test_issue.owner_id = 23456 |
| self.USERS_BY_ID[23456].user = testing_helpers.Blank(last_visit_timestamp=0) |
| cell = tablecell.TableCellOwnerLastVisit( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values, []) |
| |
| self.USERS_BY_ID[23456].user.last_visit_timestamp = int(time.time()) |
| cell = tablecell.TableCellOwnerLastVisit( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 'Today') |
| |
| self.USERS_BY_ID[23456].user.last_visit_timestamp = ( |
| int(time.time()) - 25 * framework_constants.SECS_PER_HOUR) |
| cell = tablecell.TableCellOwnerLastVisit( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 'Yesterday') |
| |
| def testTableCellBlockedOn(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.blocked_on_iids = [ |
| self.issue1.issue_id, self.issue2.issue_id, self.issue3.issue_id, |
| self.issue5.issue_id] |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws['related_issues'] = { |
| self.issue1.issue_id: self.issue1, self.issue2.issue_id: self.issue2, |
| self.issue3.issue_id: self.issue3, self.issue5.issue_id: self.issue5} |
| |
| cell = tablecell.TableCellBlockedOn( |
| test_issue, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ISSUES) |
| self.assertEqual( |
| [x.item for x in cell.values], [ |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=1', |
| id='1', |
| closed=None, |
| title='One'), |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=3', |
| id='3', |
| closed=None, |
| title='Three'), |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=5', |
| id='5', |
| closed=None, |
| title=''), |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=2', |
| id='2', |
| closed='yes', |
| title='Two') |
| ]) |
| |
| def testTableCellBlockedOnNone(self): |
| cell = tablecell.TableCellBlockedOn( |
| MakeTestIssue(4, 4, 'Four'), **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ISSUES) |
| self.assertEqual(cell.values, []) |
| |
| def testTableCellBlocking(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.blocking_iids = [ |
| self.issue1.issue_id, self.issue2.issue_id, self.issue3.issue_id, |
| self.issue5.issue_id] |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws['related_issues'] = { |
| self.issue1.issue_id: self.issue1, self.issue2.issue_id: self.issue2, |
| self.issue3.issue_id: self.issue3, self.issue5.issue_id: self.issue5} |
| |
| cell = tablecell.TableCellBlocking( |
| test_issue, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ISSUES) |
| self.assertEqual( |
| [x.item for x in cell.values], [ |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=1', |
| id='1', |
| closed=None, |
| title='One'), |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=3', |
| id='3', |
| closed=None, |
| title='Three'), |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=5', |
| id='5', |
| closed=None, |
| title=''), |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=2', |
| id='2', |
| closed='yes', |
| title='Two') |
| ]) |
| |
| def testTableCellBlockingNone(self): |
| cell = tablecell.TableCellBlocking( |
| MakeTestIssue(4, 4, 'Four'), |
| **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ISSUES) |
| self.assertEqual(cell.values, []) |
| |
| def testTableCellBlocked(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.blocked_on_iids = [1, 2, 3] |
| |
| cell = tablecell.TableCellBlocked( |
| test_issue, **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 'Yes') |
| |
| def testTableCellBlockedNotBlocked(self): |
| cell = tablecell.TableCellBlocked( |
| MakeTestIssue(4, 4, 'Four'), **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual(cell.values[0].item, 'No') |
| |
| def testTableCellMergedInto(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.merged_into = self.issue2.issue_id |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws['related_issues'] = {self.issue2.issue_id: self.issue2} |
| |
| cell = tablecell.TableCellMergedInto( |
| test_issue, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ISSUES) |
| self.assertEqual( |
| cell.values[0].item, |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=2', |
| id='2', |
| closed='yes', |
| title='Two')) |
| |
| def testTableCellMergedIntoUnviewable(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.merged_into = self.issue5.issue_id |
| table_cell_kws = self.table_cell_kws.copy() |
| table_cell_kws['related_issues'] = {self.issue5.issue_id: self.issue5} |
| |
| cell = tablecell.TableCellMergedInto( |
| test_issue, **table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ISSUES) |
| self.assertEqual( |
| cell.values[0].item, |
| template_helpers.EZTItem( |
| href='/p/None/issues/detail?id=5', id='5', closed=None, title='')) |
| |
| def testTableCellMergedIntoNotMerged(self): |
| cell = tablecell.TableCellMergedInto( |
| MakeTestIssue(4, 4, 'Four'), **self.table_cell_kws) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ISSUES) |
| self.assertEqual(cell.values, []) |
| |
| def testTableCellAllLabels(self): |
| labels = ['A', 'B', 'C', 'D-E', 'F-G'] |
| derived_labels = ['W', 'X', 'Y-Z'] |
| |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.labels = labels |
| test_issue.derived_labels = derived_labels |
| |
| cell = tablecell.TableCellAllLabels(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_ATTR) |
| self.assertEqual([v.item for v in cell.values], labels + derived_labels) |
| |
| |
| class TableCellCSVTest(unittest.TestCase): |
| |
| USERS_BY_ID = { |
| 23456: DisplayNameMock('Jason'), |
| } |
| |
| def testTableCellOpenedTimestamp(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.opened_timestamp = 1200000000 |
| |
| cell = tablecell.TableCellOpenedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 1200000000) |
| |
| def testTableCellClosedTimestamp(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.closed_timestamp = None |
| |
| cell = tablecell.TableCellClosedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 0) |
| |
| test_issue.closed_timestamp = 1200000000 |
| cell = tablecell.TableCellClosedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 1200000000) |
| |
| def testTableCellModifiedTimestamp(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.modified_timestamp = 0 |
| |
| cell = tablecell.TableCellModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 0) |
| |
| test_issue.modified_timestamp = 1200000000 |
| cell = tablecell.TableCellModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 1200000000) |
| |
| def testTableCellOwnerModifiedTimestamp(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.owner_modified_timestamp = 0 |
| |
| cell = tablecell.TableCellOwnerModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 0) |
| |
| test_issue.owner_modified_timestamp = 1200000000 |
| cell = tablecell.TableCellOwnerModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 1200000000) |
| |
| def testTableCellStatusModifiedTimestamp(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.status_modified_timestamp = 0 |
| |
| cell = tablecell.TableCellStatusModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 0) |
| |
| test_issue.status_modified_timestamp = 1200000000 |
| cell = tablecell.TableCellStatusModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 1200000000) |
| |
| def testTableCellComponentModifiedTimestamp(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.component_modified_timestamp = 0 |
| |
| cell = tablecell.TableCellComponentModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 0) |
| |
| test_issue.component_modified_timestamp = 1200000000 |
| cell = tablecell.TableCellComponentModifiedTimestamp(test_issue) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(cell.values[0].item, 1200000000) |
| |
| def testTableCellOwnerLastVisitDaysAgo(self): |
| test_issue = MakeTestIssue(4, 4, 'Four') |
| test_issue.owner_id = None |
| |
| cell = tablecell.TableCellOwnerLastVisitDaysAgo( |
| test_issue, users_by_id=self.USERS_BY_ID) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(None, cell.values[0].item) |
| |
| test_issue.owner_id = 23456 |
| self.USERS_BY_ID[23456].user = testing_helpers.Blank(last_visit_timestamp=0) |
| cell = tablecell.TableCellOwnerLastVisitDaysAgo( |
| test_issue, users_by_id=self.USERS_BY_ID) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(None, cell.values[0].item) |
| |
| self.USERS_BY_ID[23456].user.last_visit_timestamp = ( |
| int(time.time()) - 25 * 60 * 60) |
| cell = tablecell.TableCellOwnerLastVisitDaysAgo( |
| test_issue, users_by_id=self.USERS_BY_ID) |
| self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE) |
| self.assertEqual(1, cell.values[0].item) |