| # Copyright 2016 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style |
| # license that can be found in the LICENSE file or at |
| # https://developers.google.com/open-source/licenses/bsd |
| |
| """Tests for issue bizobj functions.""" |
| from __future__ import print_function |
| from __future__ import division |
| from __future__ import absolute_import |
| |
| import unittest |
| import logging |
| |
| from framework import framework_constants |
| from framework import framework_views |
| from proto import tracker_pb2 |
| from services import service_manager |
| from testing import fake |
| from testing import testing_helpers |
| from tracker import tracker_bizobj |
| from tracker import tracker_constants |
| |
| |
| class BizobjTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.cnxn = 'fake cnxn' |
| self.services = service_manager.Services( |
| issue=fake.IssueService()) |
| self.config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| self.config.field_defs = [ |
| tracker_pb2.FieldDef( |
| field_id=1, project_id=789, field_name='EstDays', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE) |
| ] |
| self.config.component_defs = [ |
| tracker_pb2.ComponentDef(component_id=1, project_id=789, path='UI'), |
| tracker_pb2.ComponentDef(component_id=2, project_id=789, path='DB'), |
| ] |
| |
| def testGetOwnerId(self): |
| issue = tracker_pb2.Issue() |
| self.assertEqual( |
| tracker_bizobj.GetOwnerId(issue), framework_constants.NO_USER_SPECIFIED) |
| |
| issue.derived_owner_id = 123 |
| self.assertEqual(tracker_bizobj.GetOwnerId(issue), 123) |
| |
| issue.owner_id = 456 |
| self.assertEqual(tracker_bizobj.GetOwnerId(issue), 456) |
| |
| def testGetStatus(self): |
| issue = tracker_pb2.Issue() |
| self.assertEqual(tracker_bizobj.GetStatus(issue), '') |
| |
| issue.derived_status = 'InReview' |
| self.assertEqual(tracker_bizobj.GetStatus(issue), 'InReview') |
| |
| issue.status = 'Forgotten' |
| self.assertEqual(tracker_bizobj.GetStatus(issue), 'Forgotten') |
| |
| def testGetCcIds(self): |
| issue = tracker_pb2.Issue() |
| self.assertEqual(tracker_bizobj.GetCcIds(issue), []) |
| |
| issue.derived_cc_ids.extend([1, 2, 3]) |
| self.assertEqual(tracker_bizobj.GetCcIds(issue), [1, 2, 3]) |
| |
| issue.cc_ids.extend([4, 5, 6]) |
| self.assertEqual(tracker_bizobj.GetCcIds(issue), [4, 5, 6, 1, 2, 3]) |
| |
| def testGetApproverIds(self): |
| issue = tracker_pb2.Issue() |
| self.assertEqual(tracker_bizobj.GetApproverIds(issue), []) |
| |
| av_1 = tracker_pb2.ApprovalValue(approver_ids=[111, 222]) |
| av_2 = tracker_pb2.ApprovalValue() |
| av_3 = tracker_pb2.ApprovalValue(approver_ids=[222, 333]) |
| issue.approval_values = [av_1, av_2, av_3] |
| self.assertItemsEqual( |
| tracker_bizobj.GetApproverIds(issue), [111, 222, 333]) |
| |
| def testGetLabels(self): |
| issue = tracker_pb2.Issue() |
| self.assertEqual(tracker_bizobj.GetLabels(issue), []) |
| |
| issue.derived_labels.extend(['a', 'b', 'c']) |
| self.assertEqual(tracker_bizobj.GetLabels(issue), ['a', 'b', 'c']) |
| |
| issue.labels.extend(['d', 'e', 'f']) |
| self.assertEqual( |
| tracker_bizobj.GetLabels(issue), ['d', 'e', 'f', 'a', 'b', 'c']) |
| |
| def testFindFieldDef_None(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| self.assertIsNone(tracker_bizobj.FindFieldDef(None, config)) |
| |
| def testFindFieldDef_Empty(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| self.assertIsNone(tracker_bizobj.FindFieldDef('EstDays', config)) |
| |
| def testFindFieldDef_Default(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| self.assertIsNone(tracker_bizobj.FindFieldDef('EstDays', config)) |
| |
| def testFindFieldDef_Normal(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef(field_name='EstDays') |
| config.field_defs = [fd] |
| self.assertEqual(fd, tracker_bizobj.FindFieldDef('EstDays', config)) |
| self.assertEqual(fd, tracker_bizobj.FindFieldDef('ESTDAYS', config)) |
| self.assertIsNone(tracker_bizobj.FindFieldDef('Unknown', config)) |
| |
| def testFindFieldDefByID_Empty(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| self.assertIsNone(tracker_bizobj.FindFieldDefByID(1, config)) |
| |
| def testFindFieldDefByID_Default(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| self.assertIsNone(tracker_bizobj.FindFieldDefByID(1, config)) |
| |
| def testFindFieldDefByID_Normal(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef(field_id=1) |
| config.field_defs = [fd] |
| self.assertEqual(fd, tracker_bizobj.FindFieldDefByID(1, config)) |
| self.assertIsNone(tracker_bizobj.FindFieldDefByID(99, config)) |
| |
| def testFindApprovalDef_Empty(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| self.assertEqual(None, tracker_bizobj.FindApprovalDef( |
| 'Nonexistent', config)) |
| |
| def testFindApprovalDef_Normal(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| approval_fd = tracker_pb2.FieldDef(field_id=1, field_name='UIApproval') |
| approval_def = tracker_pb2.ApprovalDef( |
| approval_id=1, approver_ids=[111], survey='') |
| config.field_defs = [approval_fd] |
| config.approval_defs = [approval_def] |
| self.assertEqual(approval_def, tracker_bizobj.FindApprovalDef( |
| 'UIApproval', config)) |
| |
| def testFindApprovalDef_NotApproval(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| field_def = tracker_pb2.FieldDef(field_id=1, field_name='DesignDoc') |
| config.field_defs = [field_def] |
| self.assertEqual(None, tracker_bizobj.FindApprovalDef('DesignDoc', config)) |
| |
| def testFindApprovalDefByID_Empty(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| self.assertEqual(None, tracker_bizobj.FindApprovalDefByID(1, config)) |
| |
| def testFindApprovalDefByID_Normal(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| approval_def = tracker_pb2.ApprovalDef( |
| approval_id=1, approver_ids=[111, 222], survey='') |
| config.approval_defs = [approval_def] |
| self.assertEqual(approval_def, tracker_bizobj.FindApprovalDefByID( |
| 1, config)) |
| self.assertEqual(None, tracker_bizobj.FindApprovalDefByID(99, config)) |
| |
| def testFindApprovalValueByID_Normal(self): |
| av_24 = tracker_pb2.ApprovalValue(approval_id=24) |
| av_22 = tracker_pb2.ApprovalValue() |
| self.assertEqual( |
| av_24, tracker_bizobj.FindApprovalValueByID(24, [av_22, av_24])) |
| |
| def testFindApprovalValueByID_None(self): |
| av_no_id = tracker_pb2.ApprovalValue() |
| self.assertIsNone(tracker_bizobj.FindApprovalValueByID(24, [av_no_id])) |
| |
| def testFindApprovalsSubfields(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| subfd_1 = tracker_pb2.FieldDef(approval_id=1) |
| subfd_2 = tracker_pb2.FieldDef(approval_id=2) |
| subfd_3 = tracker_pb2.FieldDef(approval_id=1) |
| subfd_4 = tracker_pb2.FieldDef() |
| config.field_defs = [subfd_1, subfd_2, subfd_3, subfd_4] |
| |
| subfields_dict = tracker_bizobj.FindApprovalsSubfields([1, 2], config) |
| self.assertItemsEqual(subfields_dict[1], [subfd_1, subfd_3]) |
| self.assertItemsEqual(subfields_dict[2], [subfd_2]) |
| self.assertItemsEqual(subfields_dict[3], []) |
| |
| def testFindPhaseByID_Normal(self): |
| canary_phase = tracker_pb2.Phase(phase_id=2, name='Canary') |
| stable_phase = tracker_pb2.Phase(name='Stable') |
| self.assertEqual( |
| canary_phase, |
| tracker_bizobj.FindPhaseByID(2, [stable_phase, canary_phase])) |
| |
| def testFindPhaseByID_None(self): |
| stable_phase = tracker_pb2.Phase(name='Stable') |
| self.assertIsNone(tracker_bizobj.FindPhaseByID(42, [stable_phase])) |
| |
| def testFindPhase_Normal(self): |
| canary_phase = tracker_pb2.Phase(phase_id=2) |
| stable_phase = tracker_pb2.Phase(name='Stable') |
| self.assertEqual(stable_phase, tracker_bizobj.FindPhase( |
| 'Stable', [stable_phase, canary_phase])) |
| |
| def testFindPhase_None(self): |
| self.assertIsNone(tracker_bizobj.FindPhase('ghost_phase', [])) |
| |
| def testGetGrantedPerms_Empty(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| issue = tracker_pb2.Issue() |
| self.assertEqual( |
| set(), tracker_bizobj.GetGrantedPerms(issue, {111}, config)) |
| |
| def testGetGrantedPerms_Default(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| issue = tracker_pb2.Issue() |
| self.assertEqual( |
| set(), tracker_bizobj.GetGrantedPerms(issue, {111}, config)) |
| |
| def testGetGrantedPerms_NothingGranted(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef(field_id=1) # Nothing granted |
| config.field_defs = [fd] |
| fv = tracker_pb2.FieldValue(field_id=1, user_id=222) |
| issue = tracker_pb2.Issue(field_values=[fv]) |
| self.assertEqual( |
| set(), |
| tracker_bizobj.GetGrantedPerms(issue, {111, 222}, config)) |
| |
| def testGetGrantedPerms_Normal(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef(field_id=1, grants_perm='Highlight') |
| config.field_defs = [fd] |
| fv = tracker_pb2.FieldValue(field_id=1, user_id=222) |
| issue = tracker_pb2.Issue(field_values=[fv]) |
| self.assertEqual( |
| set(), |
| tracker_bizobj.GetGrantedPerms(issue, {111}, config)) |
| self.assertEqual( |
| set(['highlight']), |
| tracker_bizobj.GetGrantedPerms(issue, {111, 222}, config)) |
| |
| def testLabelsByPrefix(self): |
| expected = tracker_bizobj.LabelsByPrefix( |
| ['OneWordLabel', 'Key-Value1', 'Key-Value2', 'Launch-X-Y-Z'], |
| ['launch-x']) |
| self.assertEqual( |
| {'key': ['Value1', 'Value2'], |
| 'launch-x': ['Y-Z']}, |
| expected) |
| |
| def testLabelIsMaskedByField(self): |
| self.assertIsNone(tracker_bizobj.LabelIsMaskedByField('UI', [])) |
| self.assertIsNone(tracker_bizobj.LabelIsMaskedByField('P-1', [])) |
| field_names = ['priority', 'size'] |
| self.assertIsNone(tracker_bizobj.LabelIsMaskedByField( |
| 'UI', field_names)) |
| self.assertIsNone(tracker_bizobj.LabelIsMaskedByField( |
| 'OS-All', field_names)) |
| self.assertEqual( |
| 'size', tracker_bizobj.LabelIsMaskedByField('size-xl', field_names)) |
| self.assertEqual( |
| 'size', tracker_bizobj.LabelIsMaskedByField('Size-XL', field_names)) |
| |
| def testNonMaskedLabels(self): |
| self.assertEqual([], tracker_bizobj.NonMaskedLabels([], [])) |
| field_names = ['priority', 'size'] |
| self.assertEqual([], tracker_bizobj.NonMaskedLabels([], field_names)) |
| self.assertEqual( |
| [], tracker_bizobj.NonMaskedLabels(['Size-XL'], field_names)) |
| self.assertEqual( |
| ['Hot'], tracker_bizobj.NonMaskedLabels(['Hot'], field_names)) |
| self.assertEqual( |
| ['Hot'], |
| tracker_bizobj.NonMaskedLabels(['Hot', 'Size-XL'], field_names)) |
| |
| def testMakeApprovalValue_Basic(self): |
| av = tracker_bizobj.MakeApprovalValue(2) |
| expected = tracker_pb2.ApprovalValue(approval_id=2) |
| self.assertEqual(av, expected) |
| |
| def testMakeApprovalValue_Full(self): |
| av = tracker_bizobj.MakeApprovalValue( |
| 2, approver_ids=[], status=tracker_pb2.ApprovalStatus.APPROVED, |
| setter_id=3, set_on=123, phase_id=3) |
| expected = tracker_pb2.ApprovalValue( |
| approval_id=2, approver_ids=[], |
| status=tracker_pb2.ApprovalStatus.APPROVED, |
| setter_id=3, set_on=123, phase_id=3) |
| self.assertEqual(av, expected) |
| |
| def testMakeFieldDef_Basic(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 1, 789, 'Size', tracker_pb2.FieldTypes.USER_TYPE, None, None, |
| False, False, False, None, None, None, False, |
| None, None, None, 'no_action', 'Some field', False) |
| self.assertEqual(1, fd.field_id) |
| self.assertEqual(None, fd.approval_id) |
| self.assertFalse(fd.is_phase_field) |
| self.assertFalse(fd.is_restricted_field) |
| |
| def testMakeFieldDef_Full(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 1, |
| 789, |
| 'Size', |
| tracker_pb2.FieldTypes.INT_TYPE, |
| None, |
| None, |
| False, |
| False, |
| False, |
| 1, |
| 100, |
| None, |
| False, |
| None, |
| None, |
| None, |
| 'no_action', |
| 'Some field', |
| False, |
| approval_id=4, |
| is_phase_field=True, |
| is_restricted_field=True) |
| self.assertEqual(1, fd.min_value) |
| self.assertEqual(100, fd.max_value) |
| self.assertEqual(4, fd.approval_id) |
| self.assertTrue(fd.is_phase_field) |
| self.assertTrue(fd.is_restricted_field) |
| |
| fd = tracker_bizobj.MakeFieldDef( |
| 1, |
| 789, |
| 'Size', |
| tracker_pb2.FieldTypes.STR_TYPE, |
| None, |
| None, |
| False, |
| False, |
| False, |
| None, |
| None, |
| 'A.*Z', |
| False, |
| 'EditIssue', |
| None, |
| None, |
| 'no_action', |
| 'Some field', |
| False, |
| 4, |
| is_restricted_field=False) |
| self.assertEqual('A.*Z', fd.regex) |
| self.assertEqual('EditIssue', fd.needs_perm) |
| self.assertEqual(4, fd.approval_id) |
| self.assertFalse(fd.is_restricted_field) |
| |
| def testMakeFieldDef_IntBools(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 1, |
| 789, |
| 'Size', |
| tracker_pb2.FieldTypes.INT_TYPE, |
| None, |
| None, |
| 0, |
| 0, |
| 0, |
| 1, |
| 100, |
| None, |
| 0, |
| None, |
| None, |
| None, |
| 'no_action', |
| 'Some field', |
| 0, |
| approval_id=4, |
| is_phase_field=1, |
| is_restricted_field=1) |
| self.assertFalse(fd.is_required) |
| self.assertFalse(fd.is_niche) |
| self.assertFalse(fd.is_multivalued) |
| self.assertFalse(fd.needs_member) |
| self.assertFalse(fd.is_deleted) |
| self.assertTrue(fd.is_phase_field) |
| self.assertTrue(fd.is_restricted_field) |
| |
| def testMakeFieldValue(self): |
| # Only the first value counts. |
| fv = tracker_bizobj.MakeFieldValue(1, 42, 'yay', 111, None, None, True) |
| self.assertEqual(1, fv.field_id) |
| self.assertEqual(42, fv.int_value) |
| self.assertIsNone(fv.str_value) |
| self.assertEqual(None, fv.user_id) |
| self.assertEqual(None, fv.phase_id) |
| |
| fv = tracker_bizobj.MakeFieldValue(1, None, 'yay', 111, None, None, True) |
| self.assertEqual('yay', fv.str_value) |
| self.assertEqual(None, fv.user_id) |
| |
| fv = tracker_bizobj.MakeFieldValue(1, None, None, 111, None, None, True) |
| self.assertEqual(111, fv.user_id) |
| self.assertEqual(True, fv.derived) |
| |
| fv = tracker_bizobj.MakeFieldValue( |
| 1, None, None, None, 1234567890, None, True) |
| self.assertEqual(1234567890, fv.date_value) |
| self.assertEqual(True, fv.derived) |
| |
| fv = tracker_bizobj.MakeFieldValue( |
| 1, None, None, None, None, 'www.google.com', True, phase_id=1) |
| self.assertEqual('www.google.com', fv.url_value) |
| self.assertEqual(True, fv.derived) |
| self.assertEqual(1, fv.phase_id) |
| |
| with self.assertRaises(ValueError): |
| tracker_bizobj.MakeFieldValue(1, None, None, None, None, None, True) |
| |
| def testGetFieldValueWithRawValue(self): |
| class MockUser(object): |
| def __init__(self): |
| self.email = 'test@example.com' |
| users_by_id = {111: MockUser()} |
| |
| class MockFieldValue(object): |
| def __init__( |
| self, int_value=None, str_value=None, user_id=None, |
| date_value=None, url_value=None): |
| self.int_value = int_value |
| self.str_value = str_value |
| self.user_id = user_id |
| self.date_value = date_value |
| self.url_value = url_value |
| |
| # Test user types. |
| # Use user_id from the field_value and get user from users_by_id. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.USER_TYPE, |
| users_by_id=users_by_id, |
| field_value=MockFieldValue(user_id=111), |
| raw_value=113, |
| ) |
| self.assertEqual('test@example.com', val) |
| # Specify user_id that does not exist in users_by_id. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.USER_TYPE, |
| users_by_id=users_by_id, |
| field_value=MockFieldValue(user_id=112), |
| raw_value=113, |
| ) |
| self.assertEqual(112, val) |
| # Pass in empty users_by_id. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.USER_TYPE, |
| users_by_id={}, |
| field_value=MockFieldValue(user_id=111), |
| raw_value=113, |
| ) |
| self.assertEqual(111, val) |
| # Test different raw_values. |
| raw_value_tests = ( |
| (111, 'test@example.com'), |
| (112, 112), |
| (framework_constants.NO_USER_NAME, framework_constants.NO_USER_NAME)) |
| for (raw_value, expected_output) in raw_value_tests: |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.USER_TYPE, |
| users_by_id=users_by_id, |
| field_value=None, |
| raw_value=raw_value, |
| ) |
| self.assertEqual(expected_output, val) |
| |
| # Test enum types. |
| # The returned value should be the raw_value regardless of field_value being |
| # specified. |
| for field_value in (MockFieldValue(), None): |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.ENUM_TYPE, |
| users_by_id=users_by_id, |
| field_value=field_value, |
| raw_value='abc', |
| ) |
| self.assertEqual('abc', val) |
| |
| # Test int type. |
| # Use int_value from the field_value. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, |
| users_by_id=users_by_id, |
| field_value=MockFieldValue(int_value=100), |
| raw_value=101, |
| ) |
| self.assertEqual(100, val) |
| # Use the raw_value when field_value is not specified. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, |
| users_by_id=users_by_id, |
| field_value=None, |
| raw_value=101, |
| ) |
| self.assertEqual(101, val) |
| |
| # Test str type. |
| # Use str_value from the field_value. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.STR_TYPE, |
| users_by_id=users_by_id, |
| field_value=MockFieldValue(str_value='testing'), |
| raw_value='test', |
| ) |
| self.assertEqual('testing', val) |
| # Use the raw_value when field_value is not specified. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.STR_TYPE, |
| users_by_id=users_by_id, |
| field_value=None, |
| raw_value='test', |
| ) |
| self.assertEqual('test', val) |
| |
| # Test date type. |
| # Use date_value from the field_value. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.DATE_TYPE, |
| users_by_id=users_by_id, |
| field_value=MockFieldValue(date_value=1234567890), |
| raw_value=2345678901, |
| ) |
| self.assertEqual('2009-02-13', val) |
| # Use the raw_value when field_value is not specified. |
| val = tracker_bizobj.GetFieldValueWithRawValue( |
| field_type=tracker_pb2.FieldTypes.DATE_TYPE, |
| users_by_id=users_by_id, |
| field_value=None, |
| raw_value='2016-10-30', |
| ) |
| self.assertEqual('2016-10-30', val) |
| |
| def testFindComponentDef_Empty(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| actual = tracker_bizobj.FindComponentDef('DB', config) |
| self.assertIsNone(actual) |
| |
| def testFindComponentDef_NoMatch(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(path='UI>Splash') |
| config.component_defs.append(cd) |
| actual = tracker_bizobj.FindComponentDef('DB', config) |
| self.assertIsNone(actual) |
| |
| def testFindComponentDef_MatchFound(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(path='UI>Splash') |
| config.component_defs.append(cd) |
| actual = tracker_bizobj.FindComponentDef('UI>Splash', config) |
| self.assertEqual(cd, actual) |
| |
| def testFindMatchingComponentIDs_Empty(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| actual = tracker_bizobj.FindMatchingComponentIDs('DB', config) |
| self.assertEqual([], actual) |
| actual = tracker_bizobj.FindMatchingComponentIDs('DB', config, exact=False) |
| self.assertEqual([], actual) |
| |
| def testFindMatchingComponentIDs_NoMatch(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=1, path='UI>Splash')) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=2, path='UI>AboutBox')) |
| actual = tracker_bizobj.FindMatchingComponentIDs('DB', config) |
| self.assertEqual([], actual) |
| actual = tracker_bizobj.FindMatchingComponentIDs('DB', config, exact=False) |
| self.assertEqual([], actual) |
| |
| def testFindMatchingComponentIDs_Match(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=1, path='UI>Splash')) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=2, path='UI>AboutBox')) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=3, path='DB>Attachments')) |
| actual = tracker_bizobj.FindMatchingComponentIDs('DB', config) |
| self.assertEqual([], actual) |
| actual = tracker_bizobj.FindMatchingComponentIDs('DB', config, exact=False) |
| self.assertEqual([3], actual) |
| |
| def testFindMatchingComponentIDs_MatchMultiple(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=1, path='UI>Splash')) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=2, path='UI>AboutBox')) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=22, path='UI>AboutBox')) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=3, path='DB>Attachments')) |
| actual = tracker_bizobj.FindMatchingComponentIDs('UI>AboutBox', config) |
| self.assertEqual([2, 22], actual) |
| actual = tracker_bizobj.FindMatchingComponentIDs('UI', config, exact=False) |
| self.assertEqual([1, 2, 22], actual) |
| |
| def testFindComponentDefByID_Empty(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| actual = tracker_bizobj.FindComponentDefByID(999, config) |
| self.assertIsNone(actual) |
| |
| def testFindComponentDefByID_NoMatch(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=1, path='UI>Splash')) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=2, path='UI>AboutBox')) |
| actual = tracker_bizobj.FindComponentDefByID(999, config) |
| self.assertIsNone(actual) |
| |
| def testFindComponentDefByID_MatchFound(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI>Splash') |
| config.component_defs.append(cd) |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=2, path='UI>AboutBox')) |
| actual = tracker_bizobj.FindComponentDefByID(1, config) |
| self.assertEqual(cd, actual) |
| |
| def testFindAncestorComponents_Empty(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI>Splash') |
| actual = tracker_bizobj.FindAncestorComponents(config, cd) |
| self.assertEqual([], actual) |
| |
| def testFindAncestorComponents_NoMatch(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI>Splash') |
| config.component_defs.append(tracker_pb2.ComponentDef( |
| component_id=2, path='UI>AboutBox')) |
| actual = tracker_bizobj.FindAncestorComponents(config, cd) |
| self.assertEqual([], actual) |
| |
| def testFindAncestorComponents_NoComponents(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI') |
| config.component_defs.append(cd) |
| cd2 = tracker_pb2.ComponentDef(component_id=2, path='UI>Splash') |
| config.component_defs.append(cd2) |
| actual = tracker_bizobj.FindAncestorComponents(config, cd2) |
| self.assertEqual([cd], actual) |
| |
| def testGetIssueComponentsAndAncestors_NoSuchComponent(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI') |
| config.component_defs.append(cd) |
| cd2 = tracker_pb2.ComponentDef(component_id=2, path='UI>Splash') |
| config.component_defs.append(cd2) |
| issue = tracker_pb2.Issue(component_ids=[999]) |
| actual = tracker_bizobj.GetIssueComponentsAndAncestors(issue, config) |
| self.assertEqual([], actual) |
| |
| def testGetIssueComponentsAndAncestors_AffectsNoComponents(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI') |
| config.component_defs.append(cd) |
| cd2 = tracker_pb2.ComponentDef(component_id=2, path='UI>Splash') |
| config.component_defs.append(cd2) |
| issue = tracker_pb2.Issue(component_ids=[]) |
| actual = tracker_bizobj.GetIssueComponentsAndAncestors(issue, config) |
| self.assertEqual([], actual) |
| |
| def testGetIssueComponentsAndAncestors_AffectsSomeComponents(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI') |
| config.component_defs.append(cd) |
| cd2 = tracker_pb2.ComponentDef(component_id=2, path='UI>Splash') |
| config.component_defs.append(cd2) |
| issue = tracker_pb2.Issue(component_ids=[2]) |
| actual = tracker_bizobj.GetIssueComponentsAndAncestors(issue, config) |
| self.assertEqual([cd, cd2], actual) |
| |
| def testFindDescendantComponents_Empty(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI') |
| actual = tracker_bizobj.FindDescendantComponents(config, cd) |
| self.assertEqual([], actual) |
| |
| def testFindDescendantComponents_NoMatch(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI') |
| config.component_defs.append(cd) |
| actual = tracker_bizobj.FindDescendantComponents(config, cd) |
| self.assertEqual([], actual) |
| |
| def testFindDescendantComponents_SomeMatch(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| cd = tracker_pb2.ComponentDef(component_id=1, path='UI') |
| config.component_defs.append(cd) |
| cd2 = tracker_pb2.ComponentDef(component_id=2, path='UI>Splash') |
| config.component_defs.append(cd2) |
| actual = tracker_bizobj.FindDescendantComponents(config, cd) |
| self.assertEqual([cd2], actual) |
| |
| def testMakeComponentDef(self): |
| cd = tracker_bizobj.MakeComponentDef( |
| 1, 789, 'UI', 'doc', False, [111], [222], 1234567890, |
| 111) |
| self.assertEqual(1, cd.component_id) |
| self.assertEqual([111], cd.admin_ids) |
| self.assertEqual([], cd.label_ids) |
| |
| def testMakeSavedQuery_WithNone(self): |
| sq = tracker_bizobj.MakeSavedQuery( |
| None, 'my query', 2, 'priority:high') |
| self.assertEqual(None, sq.query_id) |
| self.assertEqual(None, sq.subscription_mode) |
| self.assertEqual([], sq.executes_in_project_ids) |
| |
| def testMakeSavedQuery(self): |
| sq = tracker_bizobj.MakeSavedQuery( |
| 100, 'my query', 2, 'priority:high', |
| subscription_mode='immediate', executes_in_project_ids=[789]) |
| self.assertEqual(100, sq.query_id) |
| self.assertEqual('immediate', sq.subscription_mode) |
| self.assertEqual([789], sq.executes_in_project_ids) |
| |
| def testConvertDictToTemplate(self): |
| template = tracker_bizobj.ConvertDictToTemplate( |
| dict(name='name', content='content', summary='summary', |
| status='status', owner_id=111)) |
| self.assertEqual('name', template.name) |
| self.assertEqual('content', template.content) |
| self.assertEqual('summary', template.summary) |
| self.assertEqual('status', template.status) |
| self.assertEqual(111, template.owner_id) |
| self.assertFalse(template.summary_must_be_edited) |
| self.assertTrue(template.owner_defaults_to_member) |
| self.assertFalse(template.component_required) |
| |
| template = tracker_bizobj.ConvertDictToTemplate( |
| dict(name='name', content='content', labels=['a', 'b', 'c'])) |
| self.assertListEqual( |
| ['a', 'b', 'c'], list(template.labels)) |
| |
| template = tracker_bizobj.ConvertDictToTemplate( |
| dict(name='name', content='content', summary_must_be_edited=True, |
| owner_defaults_to_member=True, component_required=True)) |
| self.assertTrue(template.summary_must_be_edited) |
| self.assertTrue(template.owner_defaults_to_member) |
| self.assertTrue(template.component_required) |
| |
| template = tracker_bizobj.ConvertDictToTemplate( |
| dict(name='name', content='content', summary_must_be_edited=False, |
| owner_defaults_to_member=False, component_required=False)) |
| self.assertFalse(template.summary_must_be_edited) |
| self.assertFalse(template.owner_defaults_to_member) |
| self.assertFalse(template.component_required) |
| |
| def CheckDefaultConfig(self, config): |
| self.assertTrue(len(config.well_known_statuses) > 0) |
| self.assertTrue(config.statuses_offer_merge > 0) |
| self.assertTrue(len(config.well_known_labels) > 0) |
| self.assertTrue(len(config.exclusive_label_prefixes) > 0) |
| # TODO(jrobbins): test actual values from default config |
| |
| def testMakeDefaultProjectIssueConfig(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.default_template_for_developers = 1 |
| config.default_template_for_users = 2 |
| self.CheckDefaultConfig(config) |
| |
| def testHarmonizeConfigs_Empty(self): |
| harmonized = tracker_bizobj.HarmonizeConfigs([]) |
| self.CheckDefaultConfig(harmonized) |
| |
| def testHarmonizeConfigs(self): |
| c1 = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| harmonized = tracker_bizobj.HarmonizeConfigs([c1]) |
| self.assertListEqual( |
| [stat.status for stat in c1.well_known_statuses], |
| [stat.status for stat in harmonized.well_known_statuses]) |
| self.assertListEqual( |
| [lab.label for lab in c1.well_known_labels], |
| [lab.label for lab in harmonized.well_known_labels]) |
| self.assertEqual('', harmonized.default_sort_spec) |
| |
| c2 = tracker_bizobj.MakeDefaultProjectIssueConfig(678) |
| tracker_bizobj.SetConfigStatuses(c2, [ |
| ('Unconfirmed', '', True, False), |
| ('New', '', True, True), |
| ('Accepted', '', True, False), |
| ('Begun', '', True, False), |
| ('Fixed', '', False, False), |
| ('Obsolete', '', False, False)]) |
| tracker_bizobj.SetConfigLabels(c2, [ |
| ('Pri-0', '', False), |
| ('Priority-High', '', True), |
| ('Pri-1', '', False), |
| ('Priority-Medium', '', True), |
| ('Pri-2', '', False), |
| ('Priority-Low', '', True), |
| ('Pri-3', '', False), |
| ('Pri-4', '', False)]) |
| c2.default_sort_spec = 'Pri -status' |
| |
| c1.approval_defs = [ |
| tracker_pb2.ApprovalDef(approval_id=1), |
| tracker_pb2.ApprovalDef(approval_id=3), |
| ] |
| c1.field_defs = [ |
| tracker_pb2.FieldDef( |
| field_id=1, project_id=789, field_name='CowApproval', |
| field_type=tracker_pb2.FieldTypes.APPROVAL_TYPE), |
| tracker_pb2.FieldDef( |
| field_id=3, project_id=789, field_name='MooApproval', |
| field_type=tracker_pb2.FieldTypes.APPROVAL_TYPE) |
| ] |
| c2.approval_defs = [ |
| tracker_pb2.ApprovalDef(approval_id=2), |
| ] |
| c2.field_defs = [ |
| tracker_pb2.FieldDef( |
| field_id=2, project_id=788, field_name='CowApproval', |
| field_type=tracker_pb2.FieldTypes.APPROVAL_TYPE), |
| ] |
| harmonized = tracker_bizobj.HarmonizeConfigs([c1, c2]) |
| result_statuses = [stat.status |
| for stat in harmonized.well_known_statuses] |
| result_labels = [lab.label |
| for lab in harmonized.well_known_labels] |
| self.assertListEqual( |
| ['Unconfirmed', 'New', 'Accepted', 'Begun', 'Started', 'Fixed', |
| 'Obsolete', 'Verified', 'Invalid', 'Duplicate', 'WontFix', 'Done'], |
| result_statuses) |
| self.assertListEqual( |
| ['Pri-0', 'Type-Defect', 'Type-Enhancement', 'Type-Task', |
| 'Type-Other', 'Priority-Critical', 'Priority-High', |
| 'Pri-1', 'Priority-Medium', 'Pri-2', 'Priority-Low', 'Pri-3', |
| 'Pri-4'], |
| result_labels[:result_labels.index('OpSys-All')]) |
| self.assertEqual('Pri -status', harmonized.default_sort_spec.strip()) |
| self.assertItemsEqual(c1.field_defs + c2.field_defs, |
| harmonized.field_defs) |
| self.assertItemsEqual(c1.approval_defs + c2.approval_defs, |
| harmonized.approval_defs) |
| |
| def testHarmonizeConfigsMeansOpen(self): |
| c1 = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| c2 = tracker_bizobj.MakeDefaultProjectIssueConfig(678) |
| means_open = [("TT", True, True), |
| ("TF", True, False), |
| ("FT", False, True), |
| ("FF", False, False)] |
| tracker_bizobj.SetConfigStatuses(c1, [ |
| (x[0], x[0], x[1], False) |
| for x in means_open]) |
| tracker_bizobj.SetConfigStatuses(c2, [ |
| (x[0], x[0], x[2], False) |
| for x in means_open]) |
| |
| harmonized = tracker_bizobj.HarmonizeConfigs([c1, c2]) |
| for stat in harmonized.well_known_statuses: |
| self.assertEqual(stat.means_open, stat.status != "FF") |
| |
| def testHarmonizeConfigs_DeletedCustomField(self): |
| """Only non-deleted custom fields in configs are included.""" |
| harmonized = tracker_bizobj.HarmonizeConfigs([self.config]) |
| self.assertEqual(1, len(harmonized.field_defs)) |
| |
| self.config.field_defs[0].is_deleted = True |
| harmonized = tracker_bizobj.HarmonizeConfigs([self.config]) |
| self.assertEqual(0, len(harmonized.field_defs)) |
| |
| def testHarmonizeLabelOrStatusRows_Empty(self): |
| def_rows = [] |
| actual = tracker_bizobj.HarmonizeLabelOrStatusRows(def_rows) |
| self.assertEqual([], actual) |
| |
| def testHarmonizeLabelOrStatusRows_Normal(self): |
| def_rows = [ |
| (100, 789, 1, 'Priority-High'), |
| (101, 789, 2, 'Priority-Normal'), |
| (103, 789, 3, 'Priority-Low'), |
| (199, 789, None, 'Monday'), |
| (200, 678, 1, 'Priority-High'), |
| (201, 678, 2, 'Priority-Medium'), |
| (202, 678, 3, 'Priority-Low'), |
| (299, 678, None, 'Hot'), |
| ] |
| actual = tracker_bizobj.HarmonizeLabelOrStatusRows(def_rows) |
| self.assertEqual( |
| [(199, None, 'Monday'), |
| (299, None, 'Hot'), |
| (200, 1, 'Priority-High'), |
| (100, 1, 'Priority-High'), |
| (101, 2, 'Priority-Normal'), |
| (201, 2, 'Priority-Medium'), |
| (202, 3, 'Priority-Low'), |
| (103, 3, 'Priority-Low') |
| ], |
| actual) |
| |
| def testCombineOrderedLists_Empty(self): |
| self.assertEqual([], tracker_bizobj._CombineOrderedLists([])) |
| |
| def testCombineOrderedLists_Normal(self): |
| a = ['Mon', 'Wed', 'Fri'] |
| b = ['Mon', 'Tue'] |
| c = ['Wed', 'Thu'] |
| self.assertEqual(['Mon', 'Tue', 'Wed', 'Thu', 'Fri'], |
| tracker_bizobj._CombineOrderedLists([a, b, c])) |
| |
| d = ['Mon', 'StartOfWeek', 'Wed', 'MidWeek', 'Fri', 'EndOfWeek'] |
| self.assertEqual(['Mon', 'StartOfWeek', 'Tue', 'Wed', 'MidWeek', 'Thu', |
| 'Fri', 'EndOfWeek'], |
| tracker_bizobj._CombineOrderedLists([a, b, c, d])) |
| |
| def testAccumulateCombinedList_Empty(self): |
| combined_items = [] |
| combined_keys = [] |
| seen_keys_set = set() |
| tracker_bizobj._AccumulateCombinedList( |
| [], combined_items, combined_keys, seen_keys_set) |
| self.assertEqual([], combined_items) |
| self.assertEqual([], combined_keys) |
| self.assertEqual(set(), seen_keys_set) |
| |
| def testAccumulateCombinedList_Normal(self): |
| combined_items = ['a', 'b', 'C'] |
| combined_keys = ['a', 'b', 'c'] # Keys are always lowercased |
| seen_keys_set = set(['a', 'b', 'c']) |
| tracker_bizobj._AccumulateCombinedList( |
| ['b', 'x', 'C', 'd', 'a'], combined_items, combined_keys, seen_keys_set) |
| self.assertEqual(['a', 'b', 'x', 'C', 'd'], combined_items) |
| self.assertEqual(['a', 'b', 'x', 'c', 'd'], combined_keys) |
| self.assertEqual(set(['a', 'b', 'x', 'c', 'd']), seen_keys_set) |
| |
| def testAccumulateCombinedList_NormalWithKeyFunction(self): |
| combined_items = ['A', 'B', 'C'] |
| combined_keys = ['@a', '@b', '@c'] |
| seen_keys_set = set(['@a', '@b', '@c']) |
| tracker_bizobj._AccumulateCombinedList( |
| ['B', 'X', 'c', 'D', 'A'], combined_items, combined_keys, seen_keys_set, |
| key=lambda s: '@' + s) |
| self.assertEqual(['A', 'B', 'X', 'C', 'D'], combined_items) |
| self.assertEqual(['@a', '@b', '@x', '@c', '@d'], combined_keys) |
| self.assertEqual(set(['@a', '@b', '@x', '@c', '@d']), seen_keys_set) |
| |
| def testGetBuiltInQuery(self): |
| self.assertEqual( |
| 'is:open', tracker_bizobj.GetBuiltInQuery(2)) |
| self.assertEqual( |
| '', tracker_bizobj.GetBuiltInQuery(101)) |
| |
| def testUsersInvolvedInComment(self): |
| comment = tracker_pb2.IssueComment() |
| self.assertEqual({0}, tracker_bizobj.UsersInvolvedInComment(comment)) |
| |
| comment.user_id = 111 |
| self.assertEqual( |
| {111}, tracker_bizobj.UsersInvolvedInComment(comment)) |
| |
| amendment = tracker_pb2.Amendment(newvalue='foo') |
| comment.amendments.append(amendment) |
| self.assertEqual( |
| {111}, tracker_bizobj.UsersInvolvedInComment(comment)) |
| |
| amendment.added_user_ids.append(222) |
| amendment.removed_user_ids.append(333) |
| self.assertEqual({111, 222, 333}, |
| tracker_bizobj.UsersInvolvedInComment(comment)) |
| |
| def testUsersInvolvedInCommentList(self): |
| self.assertEqual(set(), tracker_bizobj.UsersInvolvedInCommentList([])) |
| |
| c1 = tracker_pb2.IssueComment() |
| c1.user_id = 111 |
| c1.amendments.append(tracker_pb2.Amendment(newvalue='foo')) |
| |
| c2 = tracker_pb2.IssueComment() |
| c2.user_id = 111 |
| c2.amendments.append(tracker_pb2.Amendment( |
| added_user_ids=[222], removed_user_ids=[333])) |
| |
| self.assertEqual({111}, |
| tracker_bizobj.UsersInvolvedInCommentList([c1])) |
| |
| self.assertEqual({111, 222, 333}, |
| tracker_bizobj.UsersInvolvedInCommentList([c2])) |
| |
| self.assertEqual({111, 222, 333}, |
| tracker_bizobj.UsersInvolvedInCommentList([c1, c2])) |
| |
| def testUsersInvolvedInIssues_Empty(self): |
| self.assertEqual(set(), tracker_bizobj.UsersInvolvedInIssues([])) |
| |
| def testUsersInvolvedInIssues_Normal(self): |
| av_1 = tracker_pb2.ApprovalValue(approver_ids=[666, 222, 444]) |
| av_2 = tracker_pb2.ApprovalValue(approver_ids=[777], setter_id=888) |
| issue1 = tracker_pb2.Issue( |
| reporter_id=111, owner_id=222, cc_ids=[222, 333], |
| approval_values=[av_1, av_2]) |
| issue2 = tracker_pb2.Issue( |
| reporter_id=333, owner_id=444, derived_cc_ids=[222, 444]) |
| issue2.field_values = [tracker_pb2.FieldValue(user_id=555)] |
| self.assertEqual( |
| set([0, 111, 222, 333, 444, 555, 666, 777, 888]), |
| tracker_bizobj.UsersInvolvedInIssues([issue1, issue2])) |
| |
| def testUsersInvolvedInTemplate_Empty(self): |
| template = tracker_bizobj.MakeIssueTemplate( |
| 'A report', 'Something went wrong', 'New', None, 'Look out!', |
| ['Priority-High'], [], [], []) |
| self.assertEqual(set(), tracker_bizobj.UsersInvolvedInTemplate(template)) |
| |
| def testUsersInvolvedInTemplate_Normal(self): |
| template = tracker_bizobj.MakeIssueTemplate( |
| 'A report', 'Something went wrong', 'New', 111, 'Look out!', |
| ['Priority-High'], [], [333, 444], []) |
| template.field_values = [ |
| tracker_bizobj.MakeFieldValue(22, None, None, 222, None, None, False), |
| tracker_bizobj.MakeFieldValue(23, None, None, 333, None, None, False), |
| tracker_bizobj.MakeFieldValue(24, None, None, 222, None, None, False), |
| tracker_bizobj.MakeFieldValue(25, None, 'pop', None, None, None, False)] |
| template.approval_values = [ |
| tracker_pb2.ApprovalValue( |
| approval_id=30, setter_id=666, approver_ids=[444, 555]), |
| tracker_pb2.ApprovalValue(approval_id=31), |
| ] |
| self.assertEqual( |
| {111, 333, 444, 222, 555, 666}, |
| tracker_bizobj.UsersInvolvedInTemplate(template)) |
| |
| def testUsersInvolvedInTemplates_NoTemplates(self): |
| self.assertEqual(set(), tracker_bizobj.UsersInvolvedInTemplates([])) |
| |
| def testUsersInvolvedInTemplates_Normal(self): |
| template1 = tracker_bizobj.MakeIssueTemplate( |
| 'A report', 'Something went wrong', 'New', 111, 'Look out!', |
| ['Priority-High'], [], [333, 444], []) |
| template1.field_values = [ |
| tracker_bizobj.MakeFieldValue(22, None, None, 222, None, None, False)] |
| |
| template2 = tracker_bizobj.MakeIssueTemplate( |
| 'dude', 'wheres my', 'New', 222, 'car', [], [], [999, 888], []) |
| template2.field_values = [ |
| tracker_bizobj.MakeFieldValue(23, None, None, 333, None, None, False)] |
| template2.approval_values = [ |
| tracker_pb2.ApprovalValue( |
| approval_id=30, setter_id=666, approver_ids=[444, 555]), |
| tracker_pb2.ApprovalValue(approval_id=31)] |
| |
| self.assertEqual( |
| {111, 333, 444, 222, 555, 666, 888, 999}, |
| tracker_bizobj.UsersInvolvedInTemplates([template1, template2])) |
| |
| def testUsersInvolvedInApprovalDefs_Empty(self): |
| """There are no user IDs given empty inputs""" |
| actual = tracker_bizobj.UsersInvolvedInApprovalDefs([], []) |
| self.assertEqual(set(), actual) |
| |
| def testsersInvolvedInApprovalDefs_Normal(self): |
| """We find user IDs mentioned in approval approvers and field admins""" |
| self.config.field_defs[0].admin_ids = [111, 222] |
| approval_def = tracker_pb2.ApprovalDef( |
| approval_id=1, approver_ids=[111, 333], survey='') |
| self.config.approval_defs = [approval_def] |
| actual = tracker_bizobj.UsersInvolvedInApprovalDefs( |
| [approval_def], [self.config.field_defs[0]]) |
| self.assertEqual({111, 222, 333}, actual) |
| |
| def testUsersInvolvedInConfig_Empty(self): |
| """There are no user IDs mentioned in a default config.""" |
| actual = tracker_bizobj.UsersInvolvedInConfig(self.config) |
| self.assertEqual(set(), actual) |
| |
| def testUsersInvolvedInConfig_Normal(self): |
| """We find user IDs mentioned components, fields, and approvals.""" |
| self.config.component_defs[0].admin_ids = [111] |
| self.config.component_defs[0].cc_ids = [444] |
| self.config.field_defs[0].admin_ids = [111, 222] |
| approval_def = tracker_pb2.ApprovalDef( |
| approval_id=1, approver_ids=[111, 333], survey='') |
| self.config.approval_defs = [approval_def] |
| actual = tracker_bizobj.UsersInvolvedInConfig(self.config) |
| self.assertEqual({111, 222, 333, 444}, actual) |
| |
| def testLabelIDsInvolvedInConfig_Empty(self): |
| """There are no label IDs mentioned in a default config.""" |
| actual = tracker_bizobj.LabelIDsInvolvedInConfig(self.config) |
| self.assertEqual(set(), actual) |
| |
| def testLabelIDsInvolvedInConfig_Normal(self): |
| """We find label IDs added by components.""" |
| self.config.component_defs[0].label_ids = [1, 2, 3] |
| actual = tracker_bizobj.LabelIDsInvolvedInConfig(self.config) |
| self.assertEqual({1, 2, 3}, actual) |
| |
| def testMakeApprovalDelta_AllSpecified(self): |
| added_fv = tracker_bizobj.MakeFieldValue( |
| 1, None, 'added str', None, None, None, False) |
| removed_fv = tracker_bizobj.MakeFieldValue( |
| 1, None, 'removed str', None, None, None, False) |
| clear_fvs = [24] |
| labels_add = ['ittly-bittly', 'piggly-wiggly'] |
| labels_remove = ['golly-goops', 'whoopsie'] |
| actual = tracker_bizobj.MakeApprovalDelta( |
| tracker_pb2.ApprovalStatus.APPROVED, 111, [222], [], |
| [added_fv], [removed_fv], clear_fvs, labels_add, labels_remove, |
| set_on=1234) |
| self.assertEqual(actual.status, tracker_pb2.ApprovalStatus.APPROVED) |
| self.assertEqual(actual.setter_id, 111) |
| self.assertEqual(actual.set_on, 1234) |
| self.assertEqual(actual.subfield_vals_add, [added_fv]) |
| self.assertEqual(actual.subfield_vals_remove, [removed_fv]) |
| self.assertEqual(actual.subfields_clear, clear_fvs) |
| self.assertEqual(actual.labels_add, labels_add) |
| self.assertEqual(actual.labels_remove, labels_remove) |
| |
| def testMakeApprovalDelta_WithNones(self): |
| added_fv = tracker_bizobj.MakeFieldValue( |
| 1, None, 'added str', None, None, None, False) |
| removed_fv = tracker_bizobj.MakeFieldValue( |
| 1, None, 'removed str', None, None, None, False) |
| clear_fields = [2] |
| labels_add = ['ittly-bittly', 'piggly-wiggly'] |
| labels_remove = ['golly-goops', 'whoopsie'] |
| actual = tracker_bizobj.MakeApprovalDelta( |
| None, 111, [222], [], |
| [added_fv], [removed_fv], clear_fields, |
| labels_add, labels_remove) |
| self.assertIsNone(actual.status) |
| self.assertIsNone(actual.setter_id) |
| self.assertIsNone(actual.set_on) |
| |
| def testMakeIssueDelta_AllSpecified(self): |
| added_fv = tracker_bizobj.MakeFieldValue( |
| 1, None, 'added str', None, None, None, False) |
| removed_fv = tracker_bizobj.MakeFieldValue( |
| 1, None, 'removed str', None, None, None, False) |
| actual = tracker_bizobj.MakeIssueDelta( |
| 'New', 111, [222], [333], [1], [2], |
| ['AddedLabel'], ['RemovedLabel'], [added_fv], [removed_fv], |
| [3], [78901], [78902], [78903], [78904], 78905, |
| 'New summary', |
| ext_blocked_on_add=['b/123', 'b/234'], |
| ext_blocked_on_remove=['b/345', 'b/456'], |
| ext_blocking_add=['b/567', 'b/678'], |
| ext_blocking_remove=['b/789', 'b/890']) |
| self.assertEqual('New', actual.status) |
| self.assertEqual(111, actual.owner_id) |
| self.assertEqual([222], actual.cc_ids_add) |
| self.assertEqual([333], actual.cc_ids_remove) |
| self.assertEqual([1], actual.comp_ids_add) |
| self.assertEqual([2], actual.comp_ids_remove) |
| self.assertEqual(['AddedLabel'], actual.labels_add) |
| self.assertEqual(['RemovedLabel'], actual.labels_remove) |
| self.assertEqual([added_fv], actual.field_vals_add) |
| self.assertEqual([removed_fv], actual.field_vals_remove) |
| self.assertEqual([3], actual.fields_clear) |
| self.assertEqual([78901], actual.blocked_on_add) |
| self.assertEqual([78902], actual.blocked_on_remove) |
| self.assertEqual([78903], actual.blocking_add) |
| self.assertEqual([78904], actual.blocking_remove) |
| self.assertEqual(78905, actual.merged_into) |
| self.assertEqual('New summary', actual.summary) |
| self.assertEqual(['b/123', 'b/234'], actual.ext_blocked_on_add) |
| self.assertEqual(['b/345', 'b/456'], actual.ext_blocked_on_remove) |
| self.assertEqual(['b/567', 'b/678'], actual.ext_blocking_add) |
| self.assertEqual(['b/789', 'b/890'], actual.ext_blocking_remove) |
| |
| def testMakeIssueDelta_WithNones(self): |
| """None for status, owner_id, or summary does not set a value.""" |
| actual = tracker_bizobj.MakeIssueDelta( |
| None, None, [], [], [], [], |
| [], [], [], [], |
| [], [], [], [], [], None, |
| None) |
| self.assertIsNone(actual.status) |
| self.assertIsNone(actual.owner_id) |
| self.assertIsNone(actual.merged_into) |
| self.assertIsNone(actual.summary) |
| |
| def testApplyLabelChanges_RemoveAndAdd(self): |
| issue = tracker_pb2.Issue( |
| labels=['tobe-removed', 'tobe-notremoved', 'tobe-removed-2']) |
| amendment = tracker_bizobj.ApplyLabelChanges( |
| issue, self.config, |
| [u'tobe-added', 'to:be-added-2'], |
| [u'tobe-removed', u'to:be-removed-2']) |
| self.assertEqual(amendment, tracker_bizobj.MakeLabelsAmendment( |
| ['tobe-added', 'tobe-added-2'], ['tobe-removed', 'tobe-removed-2'])) |
| |
| def testApplyLabelChanges_RemoveInvalidLabel(self): |
| issue = tracker_pb2.Issue(labels=[]) |
| amendment = tracker_bizobj.ApplyLabelChanges( |
| issue, self.config, [], [u'lost-car']) |
| self.assertIsNone(amendment) |
| |
| def testApplyLabelChanges_NoChangesAfterMerge(self): |
| issue = tracker_pb2.Issue(labels=['lost-car']) |
| amendment = tracker_bizobj.ApplyLabelChanges( |
| issue, self.config, [u'lost-car'], []) |
| self.assertIsNone(amendment) |
| |
| def testApplyLabelChanges_Empty(self): |
| issue = tracker_pb2.Issue(labels=[]) |
| amendment = tracker_bizobj.ApplyLabelChanges(issue, self.config, [], []) |
| self.assertIsNone(amendment) |
| |
| def testApplyFieldValueChanges(self): |
| self.config.field_defs = [ |
| tracker_pb2.FieldDef( |
| field_id=1, project_id=789, field_name='EstDays', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE), |
| tracker_pb2.FieldDef( |
| field_id=2, project_id=789, field_name='SleepHrs', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, is_phase_field=True), |
| tracker_pb2.FieldDef( |
| field_id=3, project_id=789, field_name='Chickens', |
| field_type=tracker_pb2.FieldTypes.STR_TYPE, is_phase_field=True, |
| is_multivalued=True), |
| ] |
| original_keep = [ |
| tracker_pb2.FieldValue(field_id=3, str_value='bok', phase_id=45)] |
| original_replace = [ |
| tracker_pb2.FieldValue(field_id=1, int_value=72), |
| tracker_pb2.FieldValue(field_id=2, int_value=88, phase_id=44)] |
| original_remove = [ |
| tracker_pb2.FieldValue(field_id=3, str_value='removedbok', phase_id=45), |
| ] |
| issue = tracker_pb2.Issue( |
| phases=[ |
| tracker_pb2.Phase(phase_id=45, name='high-school'), |
| tracker_pb2.Phase(phase_id=44, name='college')]) |
| issue.field_values = original_keep + original_replace + original_remove |
| |
| fvs_add_ignore = [ |
| tracker_pb2.FieldValue(field_id=3, str_value='egg', phase_id=42)] |
| fvs_add = [ |
| tracker_pb2.FieldValue(field_id=1, int_value=73), # replace |
| tracker_pb2.FieldValue(field_id=2, int_value=99, phase_id=44), #replace |
| tracker_pb2.FieldValue(field_id=2, int_value=100, phase_id=45), # added |
| # added |
| tracker_pb2.FieldValue(field_id=3, str_value='rooster', phase_id=45), |
| ] |
| fvs_remove = original_remove |
| fields_clear = [] |
| amendments = tracker_bizobj.ApplyFieldValueChanges( |
| issue, self.config, fvs_add+fvs_add_ignore, fvs_remove, fields_clear) |
| |
| self.assertEqual( |
| amendments, |
| [tracker_bizobj.MakeFieldAmendment(1, self.config, [73]), |
| tracker_bizobj.MakeFieldAmendment( |
| 2, self.config, [99], phase_name='college'), |
| tracker_bizobj.MakeFieldAmendment( |
| 2, self.config, [100], phase_name='high-school'), |
| tracker_bizobj.MakeFieldAmendment( |
| 3, self.config, ['rooster'], old_values=['removedbok'], |
| phase_name='high-school')]) |
| self.assertEqual(issue.field_values, original_keep + fvs_add) |
| |
| def testApplyIssueDelta_NoChange(self): |
| """A delta with no change should change nothing.""" |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, cc_ids=[222], labels=['a', 'b'], |
| component_ids=[1], blocked_on_iids=[78902], blocking_iids=[78903], |
| merged_into=78904, summary='Sum') |
| delta = tracker_pb2.IssueDelta() |
| |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| self.assertEqual('New', issue.status) |
| self.assertEqual(111, issue.owner_id) |
| self.assertEqual([222], issue.cc_ids) |
| self.assertEqual(['a', 'b'], issue.labels) |
| self.assertEqual([1], issue.component_ids) |
| self.assertEqual([78902], issue.blocked_on_iids) |
| self.assertEqual([78903], issue.blocking_iids) |
| self.assertEqual(78904, issue.merged_into) |
| self.assertEqual('Sum', issue.summary) |
| |
| self.assertEqual(0, len(amendments)) |
| self.assertEqual(0, len(impacted_iids)) |
| |
| def testApplyIssueDelta_BuiltInFields(self): |
| """A delta can change built-in fields.""" |
| ref_issue_70 = fake.MakeTestIssue( |
| 789, 70, 'Something that must be done before', 'New', 111) |
| self.services.issue.TestAddIssue(ref_issue_70) |
| ref_issue_71 = fake.MakeTestIssue( |
| 789, 71, 'Something that can only be done after', 'New', 111) |
| self.services.issue.TestAddIssue(ref_issue_71) |
| ref_issue_72 = fake.MakeTestIssue( |
| 789, 72, 'Something that seems the same', 'New', 111) |
| self.services.issue.TestAddIssue(ref_issue_72) |
| ref_issue_73 = fake.MakeTestIssue( |
| 789, 73, 'Something that used to seem the same', 'New', 111) |
| self.services.issue.TestAddIssue(ref_issue_73) |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, cc_ids=[222], labels=['a', 'b'], |
| component_ids=[1], blocked_on_iids=[78902], blocking_iids=[78903], |
| merged_into=ref_issue_73.issue_id, summary='Sum') |
| delta = tracker_pb2.IssueDelta( |
| status='Duplicate', owner_id=999, cc_ids_add=[333, 444], |
| comp_ids_add=[2], labels_add=['c', 'd'], |
| blocked_on_add=[ref_issue_70.issue_id], |
| blocking_add=[ref_issue_71.issue_id], |
| merged_into=ref_issue_72.issue_id, summary='New summary') |
| |
| actual_amendments, actual_impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| self.assertEqual('Duplicate', issue.status) |
| self.assertEqual(999, issue.owner_id) |
| self.assertEqual([222, 333, 444], issue.cc_ids) |
| self.assertEqual([1, 2], issue.component_ids) |
| self.assertEqual(['a', 'b', 'c', 'd'], issue.labels) |
| self.assertEqual([78902, ref_issue_70.issue_id], issue.blocked_on_iids) |
| self.assertEqual([78903, ref_issue_71.issue_id], issue.blocking_iids) |
| self.assertEqual(ref_issue_72.issue_id, issue.merged_into) |
| self.assertEqual('New summary', issue.summary) |
| |
| self.assertEqual( |
| [tracker_bizobj.MakeStatusAmendment('Duplicate', 'New'), |
| tracker_bizobj.MakeOwnerAmendment(999, 111), |
| tracker_bizobj.MakeCcAmendment([333, 444], []), |
| tracker_bizobj.MakeComponentsAmendment([2], [], self.config), |
| tracker_bizobj.MakeLabelsAmendment(['c', 'd'], []), |
| tracker_bizobj.MakeBlockedOnAmendment([(None, 70)], []), |
| tracker_bizobj.MakeBlockingAmendment([(None, 71)], []), |
| tracker_bizobj.MakeMergedIntoAmendment([(None, 72)], [(None, 73)]), |
| tracker_bizobj.MakeSummaryAmendment('New summary', 'Sum'), |
| ], |
| actual_amendments) |
| self.assertEqual( |
| set([ref_issue_70.issue_id, ref_issue_71.issue_id, |
| ref_issue_72.issue_id, ref_issue_73.issue_id]), |
| actual_impacted_iids) |
| |
| def testApplyIssueDelta_ReferrencedIssueNotFound(self): |
| """This part of the code copes with missing issues.""" |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, cc_ids=[222], labels=['a', 'b'], |
| component_ids=[1], blocked_on_iids=[78902], blocking_iids=[78903], |
| merged_into=78904, summary='Sum') |
| delta = tracker_pb2.IssueDelta( |
| blocked_on_add=[78905], blocked_on_remove=[78902], |
| blocking_add=[78906], blocking_remove=[78903], |
| merged_into=78907) |
| |
| actual_amendments, actual_impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| self.assertEqual([78905], issue.blocked_on_iids) |
| self.assertEqual([78906], issue.blocking_iids) |
| self.assertEqual(78907, issue.merged_into) |
| |
| self.assertEqual( |
| [tracker_bizobj.MakeBlockedOnAmendment([], []), |
| tracker_bizobj.MakeBlockingAmendment([], []), |
| tracker_bizobj.MakeMergedIntoAmendment([], []), |
| ], |
| actual_amendments) |
| self.assertEqual( |
| set([78902, 78903, 78905, 78906]), |
| actual_impacted_iids) |
| |
| def testApplyIssueDelta_CustomPhaseFields(self): |
| """A delta can add, remove, or clear custom phase fields.""" |
| fd_a = tracker_pb2.FieldDef( |
| field_id=1, project_id=789, field_name='a', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, |
| is_multivalued=True, is_phase_field=True) |
| fd_b = tracker_pb2.FieldDef( |
| field_id=2, project_id=789, field_name='b', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, |
| is_phase_field=True) |
| fd_c = tracker_pb2.FieldDef( |
| field_id=3, project_id=789, field_name='c', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, is_phase_field=True) |
| self.config.field_defs = [fd_a, fd_b, fd_c] |
| fv_a1_p1 = tracker_pb2.FieldValue( |
| field_id=1, int_value=1, phase_id=1) # fv |
| fv_a2_p1 = tracker_pb2.FieldValue( |
| field_id=1, int_value=2, phase_id=1) # add |
| fv_a3_p1 = tracker_pb2.FieldValue( |
| field_id=1, int_value=3, phase_id=1) # add |
| fv_b1_p1 = tracker_pb2.FieldValue( |
| field_id=2, int_value=1, phase_id=1) # add |
| fv_c2_p1 = tracker_pb2.FieldValue( |
| field_id=3, int_value=2, phase_id=1) # clear |
| |
| fv_a2_p2 = tracker_pb2.FieldValue( |
| field_id=1, int_value=2, phase_id=2) # add |
| fv_b1_p2 = tracker_pb2.FieldValue( |
| field_id=2, int_value=1, phase_id=2) # fv remove |
| fv_c1_p2 = tracker_pb2.FieldValue( |
| field_id=3, int_value=1, phase_id=2) # clear |
| |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, summary='Sum', |
| field_values=[fv_a1_p1, fv_c2_p1, fv_b1_p2, fv_c1_p2]) |
| issue.phases = [ |
| tracker_pb2.Phase(phase_id=1, name='Phase-1'), |
| tracker_pb2.Phase(phase_id=2, name='Phase-2')] |
| |
| delta = tracker_pb2.IssueDelta( |
| field_vals_add=[fv_a2_p1, fv_a3_p1, fv_b1_p1, fv_a2_p2], |
| field_vals_remove=[fv_b1_p2], fields_clear=[3]) |
| |
| actual_amendments, actual_impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| self.assertEqual( |
| [tracker_bizobj.MakeFieldAmendment( |
| 1, self.config, ['2', '3'], [], phase_name='Phase-1'), |
| tracker_bizobj.MakeFieldAmendment( |
| 1, self.config, ['2'], [], phase_name='Phase-2'), |
| tracker_bizobj.MakeFieldAmendment( |
| 2, self.config, ['1'], [], phase_name='Phase-1'), |
| tracker_bizobj.MakeFieldAmendment( |
| 2, self.config, [], ['1'], phase_name='Phase-2'), |
| tracker_bizobj.MakeFieldClearedAmendment(3, self.config)], |
| actual_amendments) |
| self.assertEqual(set(), actual_impacted_iids) |
| |
| def testApplyIssueDelta_CustomFields(self): |
| """A delta can add, remove, or clear custom fields.""" |
| fd_a = tracker_pb2.FieldDef( |
| field_id=1, project_id=789, field_name='a', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, |
| is_multivalued=True) |
| fd_b = tracker_pb2.FieldDef( |
| field_id=2, project_id=789, field_name='b', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE) |
| fd_c = tracker_pb2.FieldDef( |
| field_id=3, project_id=789, field_name='c', |
| field_type=tracker_pb2.FieldTypes.INT_TYPE) |
| fd_d = tracker_pb2.FieldDef( |
| field_id=4, project_id=789, field_name='d', |
| field_type=tracker_pb2.FieldTypes.ENUM_TYPE) |
| self.config.field_defs = [fd_a, fd_b, fd_c, fd_d] |
| fv_a1 = tracker_pb2.FieldValue(field_id=1, int_value=1) |
| fv_a2 = tracker_pb2.FieldValue(field_id=1, int_value=2) |
| fv_b1 = tracker_pb2.FieldValue(field_id=2, int_value=1) |
| fv_c1 = tracker_pb2.FieldValue(field_id=3, int_value=1) |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, labels=['d-val', 'Hot'], summary='Sum', |
| field_values=[fv_a1, fv_b1, fv_c1]) |
| delta = tracker_pb2.IssueDelta( |
| field_vals_add=[fv_a2], field_vals_remove=[fv_b1], fields_clear=[3, 4]) |
| |
| actual_amendments, actual_impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| self.assertEqual([fv_a1, fv_a2], issue.field_values) |
| self.assertEqual(['Hot'], issue.labels) |
| |
| self.assertEqual( |
| [tracker_bizobj.MakeFieldAmendment(1, self.config, ['2'], []), |
| tracker_bizobj.MakeFieldAmendment(2, self.config, [], ['1']), |
| tracker_bizobj.MakeFieldClearedAmendment(3, self.config), |
| tracker_bizobj.MakeFieldClearedAmendment(4, self.config), |
| ], |
| actual_amendments) |
| self.assertEqual(set(), actual_impacted_iids) |
| |
| def testApplyIssueDelta_ExternalRefs(self): |
| """Only applies valid issue refs from a delta.""" |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, cc_ids=[222], labels=['a', 'b'], |
| component_ids=[1], blocked_on_iids=[78902], blocking_iids=[78903], |
| merged_into=78904, summary='Sum', |
| dangling_blocked_on_refs=[ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/345'), |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/111')], |
| dangling_blocking_refs=[ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/789'), |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/222')]) |
| delta = tracker_pb2.IssueDelta( |
| # Add one valid, one invalid, and another valid. |
| ext_blocked_on_add=['b/123', 'b123', 'b/234'], |
| # Remove one valid, one invalid, and one that does not exist. |
| ext_blocked_on_remove=['b/345', 'b', 'b/456'], |
| # Add one valid, one invalid, and another valid. |
| ext_blocking_add=['b/567', 'b//123', 'b/678'], |
| # Remove one valid, one invalid, and one that does not exist. |
| ext_blocking_remove=['b/789', 'b/123/123', 'b/890']) |
| |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # Test amendments. |
| self.assertEqual(2, len(amendments)) |
| self.assertEqual(tracker_pb2.FieldID.BLOCKEDON, amendments[0].field) |
| self.assertEqual('-b/345 b/123 b/234', amendments[0].newvalue) |
| self.assertEqual(tracker_pb2.FieldID.BLOCKING, amendments[1].field) |
| self.assertEqual('-b/789 b/567 b/678', amendments[1].newvalue) |
| |
| self.assertEqual(0, len(impacted_iids)) |
| |
| # Issue refs are applied correctly and alphabetized. |
| self.assertEqual([ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/111'), |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/123'), |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/234'), |
| ], issue.dangling_blocked_on_refs) |
| self.assertEqual([ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/222'), |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/567'), |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/678'), |
| ], issue.dangling_blocking_refs) |
| |
| def testApplyIssueDelta_AddAndRemoveExtRef(self): |
| """Only applies valid issue refs from a delta.""" |
| issue = tracker_pb2.Issue( |
| status='New', |
| summary='Sum', |
| dangling_blocked_on_refs=[ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/111') |
| ], |
| dangling_blocking_refs=[ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/222') |
| ]) |
| delta = tracker_pb2.IssueDelta( |
| ext_blocked_on_add=['b/123'], |
| ext_blocked_on_remove=['b/123'], |
| ext_blocking_add=['b/456'], |
| ext_blocking_remove=['b/456']) |
| |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # Nothing changed. |
| self.assertEqual(0, len(amendments)) |
| self.assertEqual(0, len(impacted_iids)) |
| |
| self.assertEqual( |
| [tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/111')], |
| issue.dangling_blocked_on_refs) |
| self.assertEqual( |
| [tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/222')], |
| issue.dangling_blocking_refs) |
| |
| def testApplyIssueDelta_OnlyInvalidExternalRefs(self): |
| """Only applies valid issue refs from a delta.""" |
| issue = tracker_pb2.Issue( |
| status='New', |
| summary='Sum', |
| dangling_blocked_on_refs=[ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/111') |
| ], |
| dangling_blocking_refs=[ |
| tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/222') |
| ]) |
| delta = tracker_pb2.IssueDelta( |
| # Add one invalid and one that already exists. |
| ext_blocked_on_add=['b123', 'b/111'], |
| # Remove one invalid, and one that does not exist. |
| ext_blocked_on_remove=['b', 'b/456'], |
| # Add one invalid and one that already exists. |
| ext_blocking_add=['b//123', 'b/222'], |
| # Remove one invalid, and one that does not exist. |
| ext_blocking_remove=['b/123/123', 'b/890']) |
| |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # Nothing changed. |
| self.assertEqual(0, len(amendments)) |
| self.assertEqual(0, len(impacted_iids)) |
| |
| self.assertEqual( |
| [tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/111')], |
| issue.dangling_blocked_on_refs) |
| self.assertEqual( |
| [tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/222')], |
| issue.dangling_blocking_refs) |
| |
| def testApplyIssueDelta_MergedIntoExternal(self): |
| """ApplyIssueDelta applies valid mergedinto refs.""" |
| issue = tracker_pb2.Issue(status='New', owner_id=111) |
| delta = tracker_pb2.IssueDelta(merged_into_external='b/5678') |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # Test amendments. |
| self.assertEqual(1, len(amendments)) |
| self.assertEqual(tracker_pb2.FieldID.MERGEDINTO, amendments[0].field) |
| self.assertEqual('b/5678', amendments[0].newvalue) |
| |
| self.assertEqual(0, len(impacted_iids)) |
| |
| # Issue refs are applied correctly and alphabetized. |
| self.assertEqual('b/5678', issue.merged_into_external) |
| |
| def testApplyIssueDelta_MergedIntoExternalInvalid(self): |
| """ApplyIssueDelta does not accept invalid mergedinto refs.""" |
| issue = tracker_pb2.Issue(status='New', owner_id=111) |
| delta = tracker_pb2.IssueDelta(merged_into_external='a/5678') |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # No change. |
| self.assertEqual(0, len(amendments)) |
| self.assertEqual(0, len(impacted_iids)) |
| self.assertEqual(None, issue.merged_into_external) |
| |
| def testApplyIssueDelta_MergedIntoFromInternalToExternal(self): |
| """ApplyIssueDelta updates from an internal to an external ref.""" |
| self.services.issue.TestAddIssue(fake.MakeTestIssue(1, 2, 'Summary', |
| 'New', 111, issue_id=6789)) |
| issue = tracker_pb2.Issue(status='New', owner_id=111, merged_into=6789) |
| delta = tracker_pb2.IssueDelta(merged_into_external='b/5678') |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # Test amendments. |
| self.assertEqual(1, len(amendments)) |
| self.assertEqual(tracker_pb2.FieldID.MERGEDINTO, amendments[0].field) |
| self.assertEqual('-2 b/5678', amendments[0].newvalue) |
| self.assertEqual(set([6789]), impacted_iids) |
| self.assertEqual(0, issue.merged_into) |
| self.assertEqual('b/5678', issue.merged_into_external) |
| |
| def testApplyIssueDelta_MergedIntoFromExternalToInternal(self): |
| """ApplyIssueDelta updates from an external to an internalref.""" |
| self.services.issue.TestAddIssue(fake.MakeTestIssue(1, 2, 'Summary', |
| 'New', 111, issue_id=6789)) |
| issue = tracker_pb2.Issue(status='New', owner_id=111, |
| merged_into_external='b/5678') |
| delta = tracker_pb2.IssueDelta(merged_into=6789) |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # Test amendments. |
| self.assertEqual(1, len(amendments)) |
| self.assertEqual(tracker_pb2.FieldID.MERGEDINTO, amendments[0].field) |
| self.assertEqual('-b/5678 2', amendments[0].newvalue) |
| self.assertEqual(set([6789]), impacted_iids) |
| self.assertEqual(6789, issue.merged_into) |
| self.assertEqual(None, issue.merged_into_external) |
| |
| def testApplyIssueDelta_MergedIntoFromExternalToExternal(self): |
| """ApplyIssueDelta updates from an external to another external ref.""" |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, merged_into_external='b/1') |
| delta = tracker_pb2.IssueDelta(merged_into_external='b/5678') |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| |
| # Test amendments. |
| self.assertEqual(1, len(amendments)) |
| self.assertEqual(tracker_pb2.FieldID.MERGEDINTO, amendments[0].field) |
| self.assertEqual('-b/1 b/5678', amendments[0].newvalue) |
| self.assertEqual(set(), impacted_iids) |
| self.assertEqual(0, issue.merged_into) |
| self.assertEqual('b/5678', issue.merged_into_external) |
| |
| def testApplyIssueDelta_NoMergedIntoInternalAndExternal(self): |
| """ApplyIssueDelta does not allow updating the internal and external |
| merged_into fields at the same time. |
| """ |
| issue = tracker_pb2.Issue(status='New', owner_id=111, merged_into=321) |
| delta = tracker_pb2.IssueDelta(merged_into=543, |
| merged_into_external='b/5678') |
| with self.assertRaises(ValueError): |
| tracker_bizobj.ApplyIssueDelta(self.cnxn, self.services.issue, issue, |
| delta, self.config) |
| |
| def testApplyIssueDelta_RemoveExistingMergedInto(self): |
| self.services.issue.TestAddIssue( |
| fake.MakeTestIssue(1, 2, 'Summary', 'New', 111, issue_id=6789)) |
| issue = tracker_pb2.Issue(status='New', owner_id=111, merged_into=6789) |
| delta = tracker_pb2.IssueDelta(merged_into=0) |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| self.assertEqual(impacted_iids, {6789}) |
| self.assertEqual(1, len(amendments)) |
| self.assertEqual( |
| amendments[0], |
| tracker_bizobj.MakeMergedIntoAmendment( |
| [], [(issue.project_name, 2)], |
| default_project_name=issue.project_name)) |
| self.assertEqual(issue.merged_into, 0) |
| |
| def testApplyIssueDelta_RemoveExternalMergedInto(self): |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, merged_into_external='b/123') |
| delta = tracker_pb2.IssueDelta(merged_into_external='') |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| self.assertEqual(impacted_iids, set()) |
| self.assertEqual(1, len(amendments)) |
| self.assertEqual( |
| amendments[0], |
| tracker_bizobj.MakeMergedIntoAmendment( |
| [], [tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/123')])) |
| self.assertEqual(issue.merged_into_external, '') |
| |
| def testApplyIssueDelta_RemoveMergedIntoNoop(self): |
| issue = tracker_pb2.Issue( |
| status='New', owner_id=111, merged_into_external='b/123') |
| delta = tracker_pb2.IssueDelta(merged_into=0) |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| self.assertEqual(impacted_iids, set()) |
| self.assertEqual(0, len(amendments)) |
| # A noop request to remove merged_into, should not affect the existing |
| # external value. |
| self.assertIsNone(issue.merged_into) |
| self.assertEqual(issue.merged_into_external, 'b/123') |
| |
| def testApplyIssueDelta_RemoveExternalMergedIntoNoop(self): |
| self.services.issue.TestAddIssue( |
| fake.MakeTestIssue(1, 2, 'Summary', 'New', 111, issue_id=6789)) |
| issue = tracker_pb2.Issue(status='New', owner_id=111, merged_into=6789) |
| delta = tracker_pb2.IssueDelta(merged_into_external='') |
| amendments, impacted_iids = tracker_bizobj.ApplyIssueDelta( |
| self.cnxn, self.services.issue, issue, delta, self.config) |
| self.assertEqual(impacted_iids, set()) |
| self.assertEqual(len(amendments), 0) |
| # A noop request to remove merged_into_external, should not affect the |
| # existing internal merged_into value. |
| self.assertIsNone(issue.merged_into_external) |
| self.assertEqual(issue.merged_into, 6789) |
| |
| def testApplyIssueBlockRelationChanges(self): |
| """We can apply blocking and blocked_on relation changes to an issue.""" |
| |
| blocked_on = fake.MakeTestIssue( |
| 789, 2, 'Something that must be done before', 'New', 111, |
| project_name='proj') |
| self.services.issue.TestAddIssue(blocked_on) |
| blocking = fake.MakeTestIssue( |
| 789, 3, 'Something that must be done after', 'New', 111, |
| project_name='proj') |
| self.services.issue.TestAddIssue(blocking) |
| |
| issue = tracker_pb2.Issue( |
| project_name='chicken', |
| blocked_on_iids=[blocked_on.issue_id, 78904], |
| blocking_iids=[blocking.issue_id, 78905]) |
| blocked_on_add = fake.MakeTestIssue( |
| 789, 6, 'Something that must be done before', 'New', 111, |
| project_name='chicken') |
| self.services.issue.TestAddIssue(blocked_on_add) |
| blocking_add = fake.MakeTestIssue( |
| 789, 7, 'Something that must be done after', 'New', 111, |
| project_name='chicken') |
| self.services.issue.TestAddIssue(blocking_add) |
| |
| (actual_amendments, actual_impacted_iids |
| ) = tracker_bizobj.ApplyIssueBlockRelationChanges( |
| self.cnxn, |
| issue, |
| # 78904 ref already exists can't be added, shuold ignore. |
| # 78404 ref does not exist, can't be removed, should ignore. |
| # blocked_on is ignored in the add list, but honored in the remove. |
| [blocked_on_add.issue_id, 78904, blocked_on.issue_id], |
| [78404, blocked_on.issue_id], |
| # 78905 ref already exists, can't be added, should ignore. |
| # 79404 ref does not exist in issue, can't be removed, should ignore. |
| # blocking_add is ignored in the remove list, but honored in the add. |
| [blocking_add.issue_id, 78905], |
| [79404, blocking.issue_id, blocking_add.issue_id], |
| self.services.issue) |
| |
| expected_amendments = [ |
| tracker_bizobj.MakeBlockedOnAmendment( |
| [('chicken', blocked_on_add.local_id)], |
| [('proj', blocked_on.local_id)], |
| default_project_name=issue.project_name), |
| tracker_bizobj.MakeBlockingAmendment( |
| [('chicken', blocking_add.local_id)], [('proj', blocking.local_id)], |
| default_project_name=issue.project_name) |
| ] |
| self.assertEqual(actual_amendments, expected_amendments) |
| self.assertItemsEqual( |
| actual_impacted_iids, [ |
| blocked_on_add.issue_id, blocking_add.issue_id, blocked_on.issue_id, |
| blocking.issue_id |
| ]) |
| self.assertEqual(issue.blocked_on_iids, [78904, blocked_on_add.issue_id]) |
| self.assertEqual(issue.blocking_iids, [78905, blocking_add.issue_id]) |
| |
| def testApplyIssueBlockRelationChanges_Empty(self): |
| """We can handle empty blocking and blocked_on relation changes.""" |
| issue = tracker_pb2.Issue(blocked_on_iids=[78901], blocking_iids=[78902]) |
| (actual_amendments, |
| actual_impacted_iids) = tracker_bizobj.ApplyIssueBlockRelationChanges( |
| self.cnxn, issue, [], [], [], [], self.services.issue) |
| |
| self.assertEqual(actual_amendments, []) |
| self.assertEqual(actual_impacted_iids, set()) |
| self.assertEqual(issue.blocked_on_iids, [78901]) |
| self.assertEqual(issue.blocking_iids, [78902]) |
| |
| def testMakeAmendment(self): |
| amendment = tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.STATUS, 'new', [111], [222]) |
| self.assertEqual(tracker_pb2.FieldID.STATUS, amendment.field) |
| self.assertEqual('new', amendment.newvalue) |
| self.assertEqual([111], amendment.added_user_ids) |
| self.assertEqual([222], amendment.removed_user_ids) |
| |
| def testPlusMinusString(self): |
| self.assertEqual('', tracker_bizobj._PlusMinusString([], [])) |
| self.assertEqual('-a -b c d', |
| tracker_bizobj._PlusMinusString(['c', 'd'], ['a', 'b'])) |
| |
| def testPlusMinusAmendment(self): |
| amendment = tracker_bizobj._PlusMinusAmendment( |
| tracker_pb2.FieldID.STATUS, ['add1', 'add2'], ['remove1']) |
| self.assertEqual(tracker_pb2.FieldID.STATUS, amendment.field) |
| self.assertEqual('-remove1 add1 add2', amendment.newvalue) |
| |
| def testPlusMinusRefsAmendment(self): |
| ref1 = (None, 1) |
| ref2 = ('other-proj', 2) |
| amendment = tracker_bizobj._PlusMinusRefsAmendment( |
| tracker_pb2.FieldID.STATUS, [ref1], [ref2]) |
| self.assertEqual(tracker_pb2.FieldID.STATUS, amendment.field) |
| self.assertEqual('-other-proj:2 1', amendment.newvalue) |
| |
| def testMakeSummaryAmendment(self): |
| amendment = tracker_bizobj.MakeSummaryAmendment('', None) |
| self.assertEqual(tracker_pb2.FieldID.SUMMARY, amendment.field) |
| self.assertEqual('', amendment.newvalue) |
| self.assertEqual(None, amendment.oldvalue) |
| |
| amendment = tracker_bizobj.MakeSummaryAmendment('new summary', '') |
| self.assertEqual(tracker_pb2.FieldID.SUMMARY, amendment.field) |
| self.assertEqual('new summary', amendment.newvalue) |
| self.assertEqual('', amendment.oldvalue) |
| |
| def testMakeStatusAmendment(self): |
| amendment = tracker_bizobj.MakeStatusAmendment('', None) |
| self.assertEqual(tracker_pb2.FieldID.STATUS, amendment.field) |
| self.assertEqual('', amendment.newvalue) |
| self.assertEqual(None, amendment.oldvalue) |
| |
| amendment = tracker_bizobj.MakeStatusAmendment('New', '') |
| self.assertEqual(tracker_pb2.FieldID.STATUS, amendment.field) |
| self.assertEqual('New', amendment.newvalue) |
| self.assertEqual('', amendment.oldvalue) |
| |
| def testMakeOwnerAmendment(self): |
| amendment = tracker_bizobj.MakeOwnerAmendment(111, 0) |
| self.assertEqual(tracker_pb2.FieldID.OWNER, amendment.field) |
| self.assertEqual('', amendment.newvalue) |
| self.assertEqual([111], amendment.added_user_ids) |
| self.assertEqual([0], amendment.removed_user_ids) |
| |
| def testMakeCcAmendment(self): |
| amendment = tracker_bizobj.MakeCcAmendment([111], [222]) |
| self.assertEqual(tracker_pb2.FieldID.CC, amendment.field) |
| self.assertEqual('', amendment.newvalue) |
| self.assertEqual([111], amendment.added_user_ids) |
| self.assertEqual([222], amendment.removed_user_ids) |
| |
| def testMakeLabelsAmendment(self): |
| amendment = tracker_bizobj.MakeLabelsAmendment(['added1'], ['removed1']) |
| self.assertEqual(tracker_pb2.FieldID.LABELS, amendment.field) |
| self.assertEqual('-removed1 added1', amendment.newvalue) |
| |
| def testDiffValueLists(self): |
| added, removed = tracker_bizobj.DiffValueLists([], []) |
| self.assertItemsEqual([], added) |
| self.assertItemsEqual([], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists([], None) |
| self.assertItemsEqual([], added) |
| self.assertItemsEqual([], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists([1, 2], []) |
| self.assertItemsEqual([1, 2], added) |
| self.assertItemsEqual([], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists([], [8, 9]) |
| self.assertItemsEqual([], added) |
| self.assertItemsEqual([8, 9], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists([1, 2], [8, 9]) |
| self.assertItemsEqual([1, 2], added) |
| self.assertItemsEqual([8, 9], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists([1, 2, 5, 6], [5, 6, 8, 9]) |
| self.assertItemsEqual([1, 2], added) |
| self.assertItemsEqual([8, 9], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists([5, 6], [5, 6, 8, 9]) |
| self.assertItemsEqual([], added) |
| self.assertItemsEqual([8, 9], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists([1, 2, 5, 6], [5, 6]) |
| self.assertItemsEqual([1, 2], added) |
| self.assertItemsEqual([], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists( |
| [1, 2, 2, 5, 6], [5, 6, 8, 9]) |
| self.assertItemsEqual([1, 2, 2], added) |
| self.assertItemsEqual([8, 9], removed) |
| |
| added, removed = tracker_bizobj.DiffValueLists( |
| [1, 2, 5, 6], [5, 6, 8, 8, 9]) |
| self.assertItemsEqual([1, 2], added) |
| self.assertItemsEqual([8, 8, 9], removed) |
| |
| def testMakeFieldAmendment_NoSuchFieldDef(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| with self.assertRaises(ValueError): |
| tracker_bizobj.MakeFieldAmendment(1, config, ['Large'], ['Small']) |
| |
| def testMakeFieldAmendment_MultiValued(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef( |
| field_id=1, field_name='Days', is_multivalued=True) |
| config.field_defs.append(fd) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '-Mon Tue Wed', [], [], 'Days'), |
| tracker_bizobj.MakeFieldAmendment(1, config, ['Tue', 'Wed'], ['Mon'])) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '-Mon', [], [], 'Days'), |
| tracker_bizobj.MakeFieldAmendment(1, config, [], ['Mon'])) |
| |
| def testMakeFieldAmendment_MultiValuedUser(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef( |
| field_id=1, field_name='Friends', is_multivalued=True, |
| field_type=tracker_pb2.FieldTypes.USER_TYPE) |
| config.field_defs.append(fd) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '', [111], [222], 'Friends'), |
| tracker_bizobj.MakeFieldAmendment(1, config, [111], [222])) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '', [], [222], 'Friends'), |
| tracker_bizobj.MakeFieldAmendment(1, config, [], [222])) |
| |
| def testMakeFieldAmendment_SingleValued(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef(field_id=1, field_name='Size') |
| config.field_defs.append(fd) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, 'Large', [], [], 'Size'), |
| tracker_bizobj.MakeFieldAmendment(1, config, ['Large'], ['Small'])) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '----', [], [], 'Size'), |
| tracker_bizobj.MakeFieldAmendment(1, config, [], ['Small'])) |
| |
| def testMakeFieldAmendment_SingleValuedUser(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef( |
| field_id=1, field_name='Friend', |
| field_type=tracker_pb2.FieldTypes.USER_TYPE) |
| config.field_defs.append(fd) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '', [111], [], 'Friend'), |
| tracker_bizobj.MakeFieldAmendment(1, config, [111], [222])) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '', [], [], 'Friend'), |
| tracker_bizobj.MakeFieldAmendment(1, config, [], [222])) |
| |
| def testMakeFieldAmendment_PhaseField(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef( |
| field_id=1, field_name='Friend', |
| field_type=tracker_pb2.FieldTypes.USER_TYPE, is_phase_field=True) |
| config.field_defs.append(fd) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '', [111], [], 'PhaseName-Friend'), |
| tracker_bizobj.MakeFieldAmendment( |
| 1, config, [111], [222], phase_name='PhaseName')) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '', [], [], 'PhaseName-3-Friend'), |
| tracker_bizobj.MakeFieldAmendment( |
| 1, config, [], [222], phase_name='PhaseName-3')) |
| |
| def testMakeFieldClearedAmendment_FieldNotFound(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| with self.assertRaises(ValueError): |
| tracker_bizobj.MakeFieldClearedAmendment(1, config) |
| |
| def testMakeFieldClearedAmendment_Normal(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| fd = tracker_pb2.FieldDef(field_id=1, field_name='Rabbit') |
| config.field_defs.append(fd) |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '----', [], [], 'Rabbit'), |
| tracker_bizobj.MakeFieldClearedAmendment(1, config)) |
| |
| def testMakeApprovalStructureAmendment(self): |
| actual_amendment = tracker_bizobj.MakeApprovalStructureAmendment( |
| ['Chicken1', 'Chicken', 'Llama'], ['Cow', 'Chicken2', 'Llama']) |
| amendment = tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, '-Cow -Chicken2 Chicken1 Chicken', |
| [], [], 'Approvals') |
| self.assertEqual(amendment, actual_amendment) |
| |
| def testMakeApprovalStatusAmendment(self): |
| actual_amendment = tracker_bizobj.MakeApprovalStatusAmendment( |
| tracker_pb2.ApprovalStatus.APPROVED) |
| amendment = tracker_pb2.Amendment( |
| field=tracker_pb2.FieldID.CUSTOM, newvalue='approved', |
| custom_field_name='Status') |
| self.assertEqual(amendment, actual_amendment) |
| |
| def testMakeApprovalApproversAmendment(self): |
| actual_amendment = tracker_bizobj.MakeApprovalApproversAmendment( |
| [222], [333]) |
| amendment = tracker_pb2.Amendment( |
| field=tracker_pb2.FieldID.CUSTOM, newvalue='', added_user_ids=[222], |
| removed_user_ids=[333], custom_field_name='Approvers') |
| self.assertEqual(actual_amendment, amendment) |
| |
| def testMakeComponentsAmendment_NoChange(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.component_defs = [ |
| tracker_pb2.ComponentDef(component_id=1, path='UI'), |
| tracker_pb2.ComponentDef(component_id=2, path='DB')] |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.COMPONENTS, '', [], []), |
| tracker_bizobj.MakeComponentsAmendment([], [], config)) |
| |
| def testMakeComponentsAmendment_NotFound(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.component_defs = [ |
| tracker_pb2.ComponentDef(component_id=1, path='UI'), |
| tracker_pb2.ComponentDef(component_id=2, path='DB')] |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.COMPONENTS, '', [], []), |
| tracker_bizobj.MakeComponentsAmendment([99], [999], config)) |
| |
| def testMakeComponentsAmendment_Normal(self): |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.component_defs = [ |
| tracker_pb2.ComponentDef(component_id=1, path='UI'), |
| tracker_pb2.ComponentDef(component_id=2, path='DB')] |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.COMPONENTS, '-UI DB', [], []), |
| tracker_bizobj.MakeComponentsAmendment([2], [1], config)) |
| |
| def testMakeBlockedOnAmendment(self): |
| ref1 = (None, 1) |
| ref2 = ('other-proj', 2) |
| amendment = tracker_bizobj.MakeBlockedOnAmendment([ref1], [ref2]) |
| self.assertEqual(tracker_pb2.FieldID.BLOCKEDON, amendment.field) |
| self.assertEqual('-other-proj:2 1', amendment.newvalue) |
| |
| amendment = tracker_bizobj.MakeBlockedOnAmendment([ref2], [ref1]) |
| self.assertEqual(tracker_pb2.FieldID.BLOCKEDON, amendment.field) |
| self.assertEqual('-1 other-proj:2', amendment.newvalue) |
| |
| def testMakeBlockingAmendment(self): |
| ref1 = (None, 1) |
| ref2 = ('other-proj', 2) |
| amendment = tracker_bizobj.MakeBlockingAmendment([ref1], [ref2]) |
| self.assertEqual(tracker_pb2.FieldID.BLOCKING, amendment.field) |
| self.assertEqual('-other-proj:2 1', amendment.newvalue) |
| |
| def testMakeMergedIntoAmendment(self): |
| ref1 = (None, 1) |
| ref2 = ('other-proj', 2) |
| ref3 = ('chicken-proj', 3) |
| amendment = tracker_bizobj.MakeMergedIntoAmendment( |
| [ref1, None], [ref2, ref3]) |
| self.assertEqual(tracker_pb2.FieldID.MERGEDINTO, amendment.field) |
| self.assertEqual('-other-proj:2 -chicken-proj:3 1', amendment.newvalue) |
| |
| def testMakeProjectAmendment(self): |
| self.assertEqual( |
| tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.PROJECT, 'moonshot', [], []), |
| tracker_bizobj.MakeProjectAmendment('moonshot')) |
| |
| def testAmendmentString(self): |
| users_by_id = { |
| 111: framework_views.StuffUserView(111, 'username@gmail.com', True), |
| framework_constants.DELETED_USER_ID: framework_views.StuffUserView( |
| framework_constants.DELETED_USER_ID, '', True), |
| } |
| summary_amendment = tracker_bizobj.MakeSummaryAmendment('new summary', None) |
| self.assertEqual( |
| 'new summary', |
| tracker_bizobj.AmendmentString(summary_amendment, users_by_id)) |
| |
| status_amendment = tracker_bizobj.MakeStatusAmendment('', None) |
| self.assertEqual( |
| '', tracker_bizobj.AmendmentString(status_amendment, users_by_id)) |
| status_amendment = tracker_bizobj.MakeStatusAmendment('Assigned', 'New') |
| self.assertEqual( |
| 'Assigned', |
| tracker_bizobj.AmendmentString(status_amendment, users_by_id)) |
| |
| owner_amendment = tracker_bizobj.MakeOwnerAmendment(0, 0) |
| self.assertEqual( |
| '----', tracker_bizobj.AmendmentString(owner_amendment, users_by_id)) |
| owner_amendment = tracker_bizobj.MakeOwnerAmendment(111, 0) |
| self.assertEqual( |
| 'usern...@gmail.com', |
| tracker_bizobj.AmendmentString(owner_amendment, users_by_id)) |
| |
| owner_amendment_deleted = tracker_bizobj.MakeOwnerAmendment(1, 0) |
| self.assertEqual( |
| framework_constants.DELETED_USER_NAME, |
| tracker_bizobj.AmendmentString(owner_amendment_deleted, users_by_id)) |
| |
| def testAmendmentString_New(self): |
| """AmendmentString_New behaves equivalently to the old version.""" |
| # TODO(crbug.com/monorail/7571): Delete this test. |
| users_by_id = { |
| 111: |
| framework_views.StuffUserView(111, 'username@gmail.com', True), |
| framework_constants.DELETED_USER_ID: |
| framework_views.StuffUserView( |
| framework_constants.DELETED_USER_ID, '', True), |
| } |
| user_display_names = { |
| 111: |
| 'usern...@gmail.com', |
| framework_constants.DELETED_USER_ID: |
| framework_constants.DELETED_USER_NAME |
| } |
| |
| summary_amendment = tracker_bizobj.MakeSummaryAmendment('new summary', None) |
| new_str_summary = tracker_bizobj.AmendmentString_New( |
| summary_amendment, user_display_names) |
| self.assertEqual( |
| tracker_bizobj.AmendmentString(summary_amendment, users_by_id), |
| new_str_summary) |
| |
| status_amendment = tracker_bizobj.MakeStatusAmendment('', None) |
| new_str_status = tracker_bizobj.AmendmentString_New( |
| status_amendment, user_display_names) |
| self.assertEqual( |
| tracker_bizobj.AmendmentString(status_amendment, users_by_id), |
| new_str_status) |
| |
| status_amendment_2 = tracker_bizobj.MakeStatusAmendment('Assigned', 'New') |
| new_str_status_2 = tracker_bizobj.AmendmentString_New( |
| status_amendment_2, user_display_names) |
| self.assertEqual( |
| tracker_bizobj.AmendmentString(status_amendment_2, users_by_id), |
| new_str_status_2) |
| |
| owner_amendment = tracker_bizobj.MakeOwnerAmendment(0, 0) |
| new_str_owner = tracker_bizobj.AmendmentString_New( |
| owner_amendment, user_display_names) |
| self.assertEqual( |
| tracker_bizobj.AmendmentString(owner_amendment, users_by_id), |
| new_str_owner) |
| |
| owner_amendment_2 = tracker_bizobj.MakeOwnerAmendment(111, 0) |
| new_str_owner_2 = tracker_bizobj.AmendmentString_New( |
| owner_amendment_2, user_display_names) |
| self.assertEqual( |
| tracker_bizobj.AmendmentString(owner_amendment_2, users_by_id), |
| new_str_owner_2) |
| |
| owner_amendment_deleted = tracker_bizobj.MakeOwnerAmendment(1, 0) |
| new_str_owner_deleted = tracker_bizobj.AmendmentString_New( |
| owner_amendment_deleted, user_display_names) |
| self.assertEqual( |
| tracker_bizobj.AmendmentString(owner_amendment_deleted, users_by_id), |
| new_str_owner_deleted) |
| |
| |
| def testAmendmentLinks(self): |
| users_by_id = { |
| 111: framework_views.StuffUserView(111, 'foo@gmail.com', False), |
| 222: framework_views.StuffUserView(222, 'bar@gmail.com', False), |
| 333: framework_views.StuffUserView(333, 'baz@gmail.com', False), |
| framework_constants.DELETED_USER_ID: framework_views.StuffUserView( |
| framework_constants.DELETED_USER_ID, '', True), |
| } |
| # SUMMARY |
| summary_amendment = tracker_bizobj.MakeSummaryAmendment('new summary', None) |
| self.assertEqual( |
| [{'value': 'new summary', 'url': None}], |
| tracker_bizobj.AmendmentLinks(summary_amendment, users_by_id, 'proj')) |
| |
| summary_amendment = tracker_bizobj.MakeSummaryAmendment( |
| 'new summary', 'NULL') |
| self.assertEqual( |
| [{'value': 'new summary', 'url': None}], |
| tracker_bizobj.AmendmentLinks(summary_amendment, users_by_id, 'proj')) |
| |
| summary_amendment = tracker_bizobj.MakeSummaryAmendment( |
| 'new summary', 'old info') |
| self.assertEqual( |
| [{'value': 'new summary (was: old info)', 'url': None}], |
| tracker_bizobj.AmendmentLinks(summary_amendment, users_by_id, 'proj')) |
| |
| # STATUS |
| status_amendment = tracker_bizobj.MakeStatusAmendment('New', None) |
| self.assertEqual( |
| [{'value': 'New', 'url': None}], |
| tracker_bizobj.AmendmentLinks(status_amendment, users_by_id, 'proj')) |
| |
| status_amendment = tracker_bizobj.MakeStatusAmendment('New', 'NULL') |
| self.assertEqual( |
| [{'value': 'New', 'url': None}], |
| tracker_bizobj.AmendmentLinks(status_amendment, users_by_id, 'proj')) |
| |
| status_amendment = tracker_bizobj.MakeStatusAmendment( |
| 'Assigned', 'New') |
| self.assertEqual( |
| [{'value': 'Assigned (was: New)', 'url': None}], |
| tracker_bizobj.AmendmentLinks(status_amendment, users_by_id, 'proj')) |
| |
| # OWNER |
| owner_amendment = tracker_bizobj.MakeOwnerAmendment(0, 0) |
| self.assertEqual( |
| [{'value': '----', 'url': None}], |
| tracker_bizobj.AmendmentLinks(owner_amendment, users_by_id, 'proj')) |
| owner_amendment = tracker_bizobj.MakeOwnerAmendment(111, 0) |
| self.assertEqual( |
| [{'value': 'foo@gmail.com', 'url': None}], |
| tracker_bizobj.AmendmentLinks(owner_amendment, users_by_id, 'proj')) |
| |
| # BLOCKEDON, BLOCKING, MERGEDINTO |
| blocking_amendment = tracker_bizobj.MakeBlockingAmendment( |
| [(None, 123), ('blah', 234)], [(None, 345), ('blah', 456)]) |
| self.assertEqual([ |
| {'value': '-345', 'url': '/p/proj/issues/detail?id=345'}, |
| {'value': '-blah:456', 'url': '/p/blah/issues/detail?id=456'}, |
| {'value': '123', 'url': '/p/proj/issues/detail?id=123'}, |
| {'value': 'blah:234', 'url': '/p/blah/issues/detail?id=234'}], |
| tracker_bizobj.AmendmentLinks(blocking_amendment, users_by_id, 'proj')) |
| |
| # newvalue catchall |
| label_amendment = tracker_bizobj.MakeLabelsAmendment( |
| ['My-Label', 'Your-Label'], ['Their-Label']) |
| self.assertEqual([ |
| {'value': '-Their-Label', 'url': None}, |
| {'value': 'My-Label', 'url': None}, |
| {'value': 'Your-Label', 'url': None}], |
| tracker_bizobj.AmendmentLinks(label_amendment, users_by_id, 'proj')) |
| |
| # CC, or CUSTOM with user type |
| cc_amendment = tracker_bizobj.MakeCcAmendment([222, 333], [111]) |
| self.assertEqual([ |
| {'value': '-foo@gmail.com', 'url': None}, |
| {'value': 'bar@gmail.com', 'url': None}, |
| {'value': 'baz@gmail.com', 'url': None}], |
| tracker_bizobj.AmendmentLinks(cc_amendment, users_by_id, 'proj')) |
| user_amendment = tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, None, [222, 333], [111], 'ultracc') |
| self.assertEqual([ |
| {'value': '-foo@gmail.com', 'url': None}, |
| {'value': 'bar@gmail.com', 'url': None}, |
| {'value': 'baz@gmail.com', 'url': None}], |
| tracker_bizobj.AmendmentLinks(user_amendment, users_by_id, 'proj')) |
| |
| # deleted users |
| cc_amendment_deleted = tracker_bizobj.MakeCcAmendment( |
| [framework_constants.DELETED_USER_ID], []) |
| self.assertEqual( |
| [{'value': framework_constants.DELETED_USER_NAME, 'url': None}], |
| tracker_bizobj.AmendmentLinks( |
| cc_amendment_deleted, users_by_id, 'proj')) |
| |
| def testGetAmendmentFieldName_Custom(self): |
| amendment = tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.CUSTOM, None, [222, 333], [111], 'Rabbit') |
| self.assertEqual('Rabbit', tracker_bizobj.GetAmendmentFieldName(amendment)) |
| |
| def testGetAmendmentFieldName_Builtin(self): |
| amendment = tracker_bizobj.MakeAmendment( |
| tracker_pb2.FieldID.SUMMARY, 'It broke', [], []) |
| self.assertEqual('Summary', tracker_bizobj.GetAmendmentFieldName(amendment)) |
| |
| def testMakeDanglingIssueRef(self): |
| di_ref = tracker_bizobj.MakeDanglingIssueRef('proj', 123) |
| self.assertEqual('proj', di_ref.project) |
| self.assertEqual(123, di_ref.issue_id) |
| |
| def testFormatIssueURL_NoRef(self): |
| self.assertEqual('', tracker_bizobj.FormatIssueURL(None)) |
| |
| def testFormatIssueRef(self): |
| self.assertEqual('', tracker_bizobj.FormatIssueRef(None)) |
| |
| self.assertEqual( |
| 'p:1', tracker_bizobj.FormatIssueRef(('p', 1))) |
| |
| self.assertEqual( |
| '1', tracker_bizobj.FormatIssueRef((None, 1))) |
| |
| def testFormatIssueRef_External(self): |
| """Outputs shortlink as-is.""" |
| ref = tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/1234') |
| self.assertEqual('b/1234', tracker_bizobj.FormatIssueRef(ref)) |
| |
| def testFormatIssueRef_ExternalInvalid(self): |
| """Does not validate external IDs.""" |
| ref = tracker_pb2.DanglingIssueRef(ext_issue_identifier='invalid') |
| self.assertEqual('invalid', tracker_bizobj.FormatIssueRef(ref)) |
| |
| def testFormatIssueRef_Empty(self): |
| """Passes on empty values.""" |
| ref = tracker_pb2.DanglingIssueRef(ext_issue_identifier='') |
| self.assertEqual('', tracker_bizobj.FormatIssueRef(ref)) |
| |
| def testParseIssueRef(self): |
| self.assertEqual(None, tracker_bizobj.ParseIssueRef('')) |
| self.assertEqual(None, tracker_bizobj.ParseIssueRef(' \t ')) |
| |
| ref_pn, ref_id = tracker_bizobj.ParseIssueRef('1') |
| self.assertEqual(None, ref_pn) |
| self.assertEqual(1, ref_id) |
| |
| ref_pn, ref_id = tracker_bizobj.ParseIssueRef('-1') |
| self.assertEqual(None, ref_pn) |
| self.assertEqual(1, ref_id) |
| |
| ref_pn, ref_id = tracker_bizobj.ParseIssueRef('p:2') |
| self.assertEqual('p', ref_pn) |
| self.assertEqual(2, ref_id) |
| |
| ref_pn, ref_id = tracker_bizobj.ParseIssueRef('-p:2') |
| self.assertEqual('p', ref_pn) |
| self.assertEqual(2, ref_id) |
| |
| def testSafeParseIssueRef(self): |
| self.assertEqual(None, tracker_bizobj._SafeParseIssueRef('-')) |
| self.assertEqual(None, tracker_bizobj._SafeParseIssueRef('test:')) |
| ref_pn, ref_id = tracker_bizobj.ParseIssueRef('p:2') |
| self.assertEqual('p', ref_pn) |
| self.assertEqual(2, ref_id) |
| |
| def testMergeFields_NoChange(self): |
| fv1 = tracker_bizobj.MakeFieldValue(1, 42, None, None, None, None, False) |
| merged_fvs, fvs_added_dict, fvs_removed_dict = tracker_bizobj._MergeFields( |
| [fv1], [], [], []) |
| self.assertEqual([fv1], merged_fvs) |
| self.assertEqual({}, fvs_added_dict) |
| self.assertEqual({}, fvs_removed_dict) |
| |
| def testMergeFields_SingleValued(self): |
| fd = tracker_pb2.FieldDef(field_id=1, field_name='foo') |
| fv1 = tracker_bizobj.MakeFieldValue(1, 42, None, None, None, None, False) |
| fv2 = tracker_bizobj.MakeFieldValue(1, 43, None, None, None, None, False) |
| fv3 = tracker_bizobj.MakeFieldValue(1, 44, None, None, None, None, False) |
| |
| # Adding one replaces all values since the field is single-valued. |
| merged_fvs, fvs_added_dict, fvs_removed_dict = tracker_bizobj._MergeFields( |
| [fv1, fv2], [fv3], [], [fd]) |
| self.assertEqual([fv3], merged_fvs) |
| self.assertEqual({fv3.field_id: [fv3]}, fvs_added_dict) |
| self.assertEqual({}, fvs_removed_dict) |
| |
| # Removing one just removes it, does not reset. |
| merged_fvs, fvs_added_dict, fvs_removed_dict = tracker_bizobj._MergeFields( |
| [fv1, fv2], [], [fv2], [fd]) |
| self.assertEqual([fv1], merged_fvs) |
| self.assertEqual({}, fvs_added_dict) |
| self.assertEqual({fv2.field_id: [fv2]}, fvs_removed_dict) |
| |
| def testMergeFields_SingleValuedPhase(self): |
| fd = tracker_pb2.FieldDef( |
| field_id=1, field_name='phase-foo', is_phase_field=True) |
| fv1 = tracker_bizobj.MakeFieldValue( |
| 1, 45, None, None, None, None, False, phase_id=1) |
| fv2 = tracker_bizobj.MakeFieldValue( |
| 1, 46, None, None, None, None, False, phase_id=2) |
| fv3 = tracker_bizobj.MakeFieldValue( |
| 1, 47, None, None, None, None, False, phase_id=1) # should replace fv4 |
| |
| # Adding one replaces all values since the field is single-valued. |
| merged_fvs, fvs_added_dict, fvs_removed_dict = tracker_bizobj._MergeFields( |
| [fv1, fv2], [fv3], [], [fd]) |
| self.assertEqual([fv2, fv3], merged_fvs) |
| self.assertEqual({fv3.field_id: [fv3]}, fvs_added_dict) |
| self.assertEqual({}, fvs_removed_dict) |
| |
| # Removing one just removes it, does not reset. |
| merged_fvs, fvs_added_dict, fvs_removed_dict = tracker_bizobj._MergeFields( |
| [fv1, fv2], [], [fv2], [fd]) |
| self.assertEqual([fv1], merged_fvs) |
| self.assertEqual({}, fvs_added_dict) |
| self.assertEqual({fv2.field_id: [fv2]}, fvs_removed_dict) |
| |
| def testMergeFields_MultiValued(self): |
| fd = tracker_pb2.FieldDef( |
| field_id=1, field_name='foo', is_multivalued=True) |
| fv1 = tracker_bizobj.MakeFieldValue(1, 42, None, None, None, None, False) |
| fv2 = tracker_bizobj.MakeFieldValue(1, 43, None, None, None, None, False) |
| fv3 = tracker_bizobj.MakeFieldValue(1, 44, None, None, None, None, False) |
| fv4 = tracker_bizobj.MakeFieldValue(1, 42, None, None, None, None, False) |
| fv5 = tracker_bizobj.MakeFieldValue(1, 99, None, None, None, None, False) |
| fv6 = tracker_bizobj.MakeFieldValue(1, 100, None, None, None, None, False) |
| |
| merged_fvs, fvs_added_dict, fvs_removed_dict = tracker_bizobj._MergeFields( |
| [fv1, fv2], [fv2, fv3, fv6], [fv4, fv5], [fd]) |
| self.assertEqual([fv2, fv3, fv6], merged_fvs) |
| self.assertEqual({fv3.field_id: [fv3, fv6]}, fvs_added_dict) |
| self.assertEqual({fv4.field_id: [fv4]}, fvs_removed_dict) |
| |
| def testMergeFields_MultiValuedPhase(self): |
| fd = tracker_pb2.FieldDef( |
| field_id=1, field_name='foo', is_multivalued=True, is_phase_field=True) |
| fd2 = tracker_pb2.FieldDef( |
| field_id=2, field_name='cow', is_multivalued=True, is_phase_field=True) |
| fv1 = tracker_bizobj.MakeFieldValue( |
| 1, 42, None, None, None, None, False, phase_id=1) |
| fv2 = tracker_bizobj.MakeFieldValue( |
| 1, 43, None, None, None, None, False, phase_id=2) |
| fv3 = tracker_bizobj.MakeFieldValue( |
| 1, 44, None, None, None, None, False, phase_id=1) |
| fv4 = tracker_bizobj.MakeFieldValue( |
| 1, 99, None, None, None, None, False, phase_id=2) |
| fv5 = tracker_bizobj.MakeFieldValue( |
| 2, 22, None, None, None, None, False, phase_id=2) |
| |
| merged_fvs, fvs_added_dict, fvs_removed_dict = tracker_bizobj._MergeFields( |
| [fv1, fv2], [fv3, fv1, fv5], [fv2, fv4], [fd, fd2]) |
| self.assertEqual([fv1, fv3, fv5], merged_fvs) |
| self.assertEqual({fv3.field_id: [fv3], fv5.field_id: [fv5]}, fvs_added_dict) |
| self.assertEqual({fv2.field_id: [fv2]}, fvs_removed_dict) |
| |
| def testSplitBlockedOnRanks_Normal(self): |
| issue = tracker_pb2.Issue() |
| issue.blocked_on_iids = [78902, 78903, 78904] |
| issue.blocked_on_ranks = [10, 20, 30] |
| rank_rows = list(zip(issue.blocked_on_iids, issue.blocked_on_ranks)) |
| rank_rows.reverse() |
| ret = tracker_bizobj.SplitBlockedOnRanks( |
| issue, 78903, False, issue.blocked_on_iids) |
| self.assertEqual(ret, (rank_rows[:1], rank_rows[1:])) |
| |
| def testSplitBlockedOnRanks_BadTarget(self): |
| issue = tracker_pb2.Issue() |
| issue.blocked_on_iids = [78902, 78903, 78904] |
| issue.blocked_on_ranks = [10, 20, 30] |
| rank_rows = list(zip(issue.blocked_on_iids, issue.blocked_on_ranks)) |
| rank_rows.reverse() |
| ret = tracker_bizobj.SplitBlockedOnRanks( |
| issue, 78999, False, issue.blocked_on_iids) |
| self.assertEqual(ret, (rank_rows, [])) |