| # 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 |
| |
| """Unittest for the tracker helpers module.""" |
| from __future__ import print_function |
| from __future__ import division |
| from __future__ import absolute_import |
| |
| import copy |
| import mock |
| import unittest |
| |
| import settings |
| |
| from businesslogic import work_env |
| from framework import exceptions |
| from framework import framework_constants |
| from framework import framework_helpers |
| from framework import permissions |
| from framework import template_helpers |
| from framework import urls |
| from proto import project_pb2 |
| from proto import tracker_pb2 |
| from proto import user_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 |
| from tracker import tracker_helpers |
| |
| TEST_ID_MAP = { |
| 'a@example.com': 1, |
| 'b@example.com': 2, |
| 'c@example.com': 3, |
| 'd@example.com': 4, |
| } |
| |
| |
| def _Issue(project_name, local_id, summary='', status='', project_id=789): |
| issue = tracker_pb2.Issue() |
| issue.project_name = project_name |
| issue.project_id = project_id |
| issue.local_id = local_id |
| issue.issue_id = 100000 + local_id |
| issue.summary = summary |
| issue.status = status |
| return issue |
| |
| |
| def _MakeConfig(): |
| config = tracker_pb2.ProjectIssueConfig() |
| config.well_known_statuses.append(tracker_pb2.StatusDef( |
| means_open=True, status='New', deprecated=False)) |
| config.well_known_statuses.append(tracker_pb2.StatusDef( |
| status='Old', means_open=False, deprecated=False)) |
| config.well_known_statuses.append(tracker_pb2.StatusDef( |
| status='StatusThatWeDontUseAnymore', means_open=False, deprecated=True)) |
| |
| return config |
| |
| |
| class HelpersTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.services = service_manager.Services( |
| project=fake.ProjectService(), |
| config=fake.ConfigService(), |
| issue=fake.IssueService(), |
| user=fake.UserService(), |
| usergroup=fake.UserGroupService()) |
| |
| for email, user_id in TEST_ID_MAP.items(): |
| self.services.user.TestAddUser(email, user_id) |
| |
| self.services.project.TestAddProject('testproj', project_id=789) |
| self.issue1 = fake.MakeTestIssue(789, 1, 'one', 'New', 111) |
| self.issue1.project_name = 'testproj' |
| self.services.issue.TestAddIssue(self.issue1) |
| self.issue2 = fake.MakeTestIssue(789, 2, 'two', 'New', 111) |
| self.issue2.project_name = 'testproj' |
| self.services.issue.TestAddIssue(self.issue2) |
| self.issue3 = fake.MakeTestIssue(789, 3, 'three', 'New', 111) |
| self.issue3.project_name = 'testproj' |
| self.services.issue.TestAddIssue(self.issue3) |
| self.cnxn = 'fake connextion' |
| self.errors = template_helpers.EZTError() |
| self.default_colspec_param = 'colspec=%s' % ( |
| tracker_constants.DEFAULT_COL_SPEC.replace(' ', '%20')) |
| self.services.usergroup.TestAddGroupSettings(999, 'group@example.com') |
| |
| def testParseIssueRequest_Empty(self): |
| post_data = fake.PostData() |
| errors = template_helpers.EZTError() |
| parsed = tracker_helpers.ParseIssueRequest( |
| 'fake cnxn', post_data, self.services, errors, 'proj') |
| self.assertEqual('', parsed.summary) |
| self.assertEqual('', parsed.comment) |
| self.assertEqual('', parsed.status) |
| self.assertEqual('', parsed.users.owner_username) |
| self.assertEqual(0, parsed.users.owner_id) |
| self.assertEqual([], parsed.users.cc_usernames) |
| self.assertEqual([], parsed.users.cc_usernames_remove) |
| self.assertEqual([], parsed.users.cc_ids) |
| self.assertEqual([], parsed.users.cc_ids_remove) |
| self.assertEqual('', parsed.template_name) |
| self.assertEqual([], parsed.labels) |
| self.assertEqual([], parsed.labels_remove) |
| self.assertEqual({}, parsed.fields.vals) |
| self.assertEqual({}, parsed.fields.vals_remove) |
| self.assertEqual([], parsed.fields.fields_clear) |
| self.assertEqual('', parsed.blocked_on.entered_str) |
| self.assertEqual([], parsed.blocked_on.iids) |
| |
| def testParseIssueRequest_Normal(self): |
| post_data = fake.PostData({ |
| 'summary': ['some summary'], |
| 'comment': ['some comment'], |
| 'status': ['SomeStatus'], |
| 'template_name': ['some template'], |
| 'label': ['lab1', '-lab2'], |
| 'custom_123': ['field1123a', 'field1123b'], |
| }) |
| errors = template_helpers.EZTError() |
| parsed = tracker_helpers.ParseIssueRequest( |
| 'fake cnxn', post_data, self.services, errors, 'proj') |
| self.assertEqual('some summary', parsed.summary) |
| self.assertEqual('some comment', parsed.comment) |
| self.assertEqual('SomeStatus', parsed.status) |
| self.assertEqual('', parsed.users.owner_username) |
| self.assertEqual(0, parsed.users.owner_id) |
| self.assertEqual([], parsed.users.cc_usernames) |
| self.assertEqual([], parsed.users.cc_usernames_remove) |
| self.assertEqual([], parsed.users.cc_ids) |
| self.assertEqual([], parsed.users.cc_ids_remove) |
| self.assertEqual('some template', parsed.template_name) |
| self.assertEqual(['lab1'], parsed.labels) |
| self.assertEqual(['lab2'], parsed.labels_remove) |
| self.assertEqual({123: ['field1123a', 'field1123b']}, parsed.fields.vals) |
| self.assertEqual({}, parsed.fields.vals_remove) |
| self.assertEqual([], parsed.fields.fields_clear) |
| |
| def testMarkupDescriptionOnInput(self): |
| content = 'What?\nthat\nWhy?\nidk\nWhere?\n' |
| tmpl_txt = 'What?\nWhy?\nWhere?\nWhen?' |
| desc = '<b>What?</b>\nthat\n<b>Why?</b>\nidk\n<b>Where?</b>\n' |
| self.assertEqual(tracker_helpers.MarkupDescriptionOnInput( |
| content, tmpl_txt), desc) |
| |
| def testMarkupDescriptionLineOnInput(self): |
| line = 'What happened??' |
| tmpl_lines = ['What happened??','Why?'] |
| self.assertEqual(tracker_helpers._MarkupDescriptionLineOnInput( |
| line, tmpl_lines), '<b>What happened??</b>') |
| |
| line = 'Something terrible!!!' |
| self.assertEqual(tracker_helpers._MarkupDescriptionLineOnInput( |
| line, tmpl_lines), 'Something terrible!!!') |
| |
| def testClassifyPlusMinusItems(self): |
| add, remove = tracker_helpers._ClassifyPlusMinusItems([]) |
| self.assertEqual([], add) |
| self.assertEqual([], remove) |
| |
| add, remove = tracker_helpers._ClassifyPlusMinusItems( |
| ['', ' ', ' \t', '-']) |
| self.assertItemsEqual([], add) |
| self.assertItemsEqual([], remove) |
| |
| add, remove = tracker_helpers._ClassifyPlusMinusItems( |
| ['a', 'b', 'c']) |
| self.assertItemsEqual(['a', 'b', 'c'], add) |
| self.assertItemsEqual([], remove) |
| |
| add, remove = tracker_helpers._ClassifyPlusMinusItems( |
| ['a-a-a', 'b-b', 'c-']) |
| self.assertItemsEqual(['a-a-a', 'b-b', 'c-'], add) |
| self.assertItemsEqual([], remove) |
| |
| add, remove = tracker_helpers._ClassifyPlusMinusItems( |
| ['-a']) |
| self.assertItemsEqual([], add) |
| self.assertItemsEqual(['a'], remove) |
| |
| add, remove = tracker_helpers._ClassifyPlusMinusItems( |
| ['-a', 'b', 'c-c']) |
| self.assertItemsEqual(['b', 'c-c'], add) |
| self.assertItemsEqual(['a'], remove) |
| |
| add, remove = tracker_helpers._ClassifyPlusMinusItems( |
| ['-a', '-b-b', '-c-']) |
| self.assertItemsEqual([], add) |
| self.assertItemsEqual(['a', 'b-b', 'c-'], remove) |
| |
| # We dedup, but we don't cancel out items that are both added and removed. |
| add, remove = tracker_helpers._ClassifyPlusMinusItems( |
| ['a', 'a', '-a']) |
| self.assertItemsEqual(['a'], add) |
| self.assertItemsEqual(['a'], remove) |
| |
| def testParseIssueRequestFields(self): |
| parsed_fields = tracker_helpers._ParseIssueRequestFields(fake.PostData({ |
| 'custom_1': ['https://hello.com'], |
| 'custom_12': ['https://blah.com'], |
| 'custom_14': ['https://remove.com'], |
| 'custom_15_goats': ['2', '3'], |
| 'custom_15_sheep': ['3', '5'], |
| 'custom_16_sheep': ['yarn'], |
| 'op_custom_14': ['remove'], |
| 'op_custom_12': ['clear'], |
| 'op_custom_16_sheep': ['remove'], |
| 'ignore': 'no matter',})) |
| self.assertEqual( |
| parsed_fields, |
| tracker_helpers.ParsedFields( |
| { |
| 1: ['https://hello.com'], |
| 12: ['https://blah.com'] |
| }, {14: ['https://remove.com']}, [12], |
| {15: { |
| 'goats': ['2', '3'], |
| 'sheep': ['3', '5'] |
| }}, {16: { |
| 'sheep': ['yarn'] |
| }})) |
| |
| def testParseIssueRequestAttachments(self): |
| file1 = testing_helpers.Blank( |
| filename='hello.c', |
| value='hello world') |
| |
| file2 = testing_helpers.Blank( |
| filename='README', |
| value='Welcome to our project') |
| |
| file3 = testing_helpers.Blank( |
| filename='c:\\dir\\subdir\\FILENAME.EXT', |
| value='Abort, Retry, or Fail?') |
| |
| # Browsers send this if FILE field was not filled in. |
| file4 = testing_helpers.Blank( |
| filename='', |
| value='') |
| |
| attachments = tracker_helpers._ParseIssueRequestAttachments({}) |
| self.assertEqual([], attachments) |
| |
| attachments = tracker_helpers._ParseIssueRequestAttachments(fake.PostData({ |
| 'file1': [file1], |
| })) |
| self.assertEqual( |
| [('hello.c', 'hello world', 'text/plain')], |
| attachments) |
| |
| attachments = tracker_helpers._ParseIssueRequestAttachments(fake.PostData({ |
| 'file1': [file1], |
| 'file2': [file2], |
| })) |
| self.assertEqual( |
| [('hello.c', 'hello world', 'text/plain'), |
| ('README', 'Welcome to our project', 'text/plain')], |
| attachments) |
| |
| attachments = tracker_helpers._ParseIssueRequestAttachments(fake.PostData({ |
| 'file3': [file3], |
| })) |
| self.assertEqual( |
| [('FILENAME.EXT', 'Abort, Retry, or Fail?', |
| 'application/octet-stream')], |
| attachments) |
| |
| attachments = tracker_helpers._ParseIssueRequestAttachments(fake.PostData({ |
| 'file1': [file4], # Does not appear in result |
| 'file3': [file3], |
| 'file4': [file4], # Does not appear in result |
| })) |
| self.assertEqual( |
| [('FILENAME.EXT', 'Abort, Retry, or Fail?', |
| 'application/octet-stream')], |
| attachments) |
| |
| def testParseIssueRequestKeptAttachments(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| def testParseIssueRequestUsers(self): |
| post_data = {} |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('', parsed_users.owner_username) |
| self.assertEqual( |
| framework_constants.NO_USER_SPECIFIED, parsed_users.owner_id) |
| self.assertEqual([], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertEqual([], parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'owner': [''], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('', parsed_users.owner_username) |
| self.assertEqual( |
| framework_constants.NO_USER_SPECIFIED, parsed_users.owner_id) |
| self.assertEqual([], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertEqual([], parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'owner': [' \t'], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('', parsed_users.owner_username) |
| self.assertEqual( |
| framework_constants.NO_USER_SPECIFIED, parsed_users.owner_id) |
| self.assertEqual([], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertEqual([], parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'owner': ['b@example.com'], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('b@example.com', parsed_users.owner_username) |
| self.assertEqual(TEST_ID_MAP['b@example.com'], parsed_users.owner_id) |
| self.assertEqual([], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertEqual([], parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'owner': ['b@example.com'], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('b@example.com', parsed_users.owner_username) |
| self.assertEqual(TEST_ID_MAP['b@example.com'], parsed_users.owner_id) |
| self.assertEqual([], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertEqual([], parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'cc': ['b@example.com'], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('', parsed_users.owner_username) |
| self.assertEqual( |
| framework_constants.NO_USER_SPECIFIED, parsed_users.owner_id) |
| self.assertEqual(['b@example.com'], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertEqual([TEST_ID_MAP['b@example.com']], parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'cc': ['-b@example.com, c@example.com,,' |
| 'a@example.com,'], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('', parsed_users.owner_username) |
| self.assertEqual( |
| framework_constants.NO_USER_SPECIFIED, parsed_users.owner_id) |
| self.assertItemsEqual(['c@example.com', 'a@example.com'], |
| parsed_users.cc_usernames) |
| self.assertEqual(['b@example.com'], parsed_users.cc_usernames_remove) |
| self.assertItemsEqual([TEST_ID_MAP['c@example.com'], |
| TEST_ID_MAP['a@example.com']], |
| parsed_users.cc_ids) |
| self.assertEqual([TEST_ID_MAP['b@example.com']], |
| parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'owner': ['fuhqwhgads@example.com'], |
| 'cc': ['c@example.com, fuhqwhgads@example.com'], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertEqual('fuhqwhgads@example.com', parsed_users.owner_username) |
| gen_uid = framework_helpers.MurmurHash3_x86_32(parsed_users.owner_username) |
| self.assertEqual(gen_uid, parsed_users.owner_id) # autocreated user |
| self.assertItemsEqual( |
| ['c@example.com', 'fuhqwhgads@example.com'], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertItemsEqual( |
| [TEST_ID_MAP['c@example.com'], gen_uid], parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| post_data = fake.PostData({ |
| 'cc': ['C@example.com, b@exAmple.cOm'], |
| }) |
| parsed_users = tracker_helpers._ParseIssueRequestUsers( |
| 'fake connection', post_data, self.services) |
| self.assertItemsEqual( |
| ['c@example.com', 'b@example.com'], parsed_users.cc_usernames) |
| self.assertEqual([], parsed_users.cc_usernames_remove) |
| self.assertItemsEqual( |
| [TEST_ID_MAP['c@example.com'], TEST_ID_MAP['b@example.com']], |
| parsed_users.cc_ids) |
| self.assertEqual([], parsed_users.cc_ids_remove) |
| |
| def testParseBlockers_BlockedOnNothing(self): |
| """Was blocked on nothing, still nothing.""" |
| post_data = {tracker_helpers.BLOCKED_ON: ''} |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKED_ON) |
| |
| self.assertEqual('', parsed_blockers.entered_str) |
| self.assertEqual([], parsed_blockers.iids) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKING)) |
| |
| def testParseBlockers_BlockedOnAdded(self): |
| """Was blocked on nothing; now 1, 2, 3.""" |
| post_data = {tracker_helpers.BLOCKED_ON: '1, 2, 3'} |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKED_ON) |
| |
| self.assertEqual('1, 2, 3', parsed_blockers.entered_str) |
| self.assertEqual([100001, 100002, 100003], parsed_blockers.iids) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKING)) |
| |
| def testParseBlockers_BlockedOnDuplicateRef(self): |
| """Was blocked on nothing; now just 2, but repeated in input.""" |
| post_data = {tracker_helpers.BLOCKED_ON: '2, 2, 2'} |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKED_ON) |
| |
| self.assertEqual('2, 2, 2', parsed_blockers.entered_str) |
| self.assertEqual([100002], parsed_blockers.iids) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKING)) |
| |
| def testParseBlockers_Missing(self): |
| """Parsing an input field that was not in the POST.""" |
| post_data = {} |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKED_ON) |
| |
| self.assertEqual('', parsed_blockers.entered_str) |
| self.assertEqual([], parsed_blockers.iids) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKING)) |
| |
| def testParseBlockers_SameIssueNoProject(self): |
| """Adding same issue as blocker should modify the errors object.""" |
| post_data = {'id': '2', tracker_helpers.BLOCKING: '2, 3'} |
| |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKING) |
| self.assertEqual('2, 3', parsed_blockers.entered_str) |
| self.assertEqual([], parsed_blockers.iids) |
| self.assertEqual( |
| getattr(self.errors, tracker_helpers.BLOCKING), |
| 'Cannot be blocking the same issue') |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| |
| def testParseBlockers_SameIssueSameProject(self): |
| """Adding same issue as blocker should modify the errors object.""" |
| post_data = {'id': '2', tracker_helpers.BLOCKING: 'testproj:2, 3'} |
| |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKING) |
| self.assertEqual('testproj:2, 3', parsed_blockers.entered_str) |
| self.assertEqual([], parsed_blockers.iids) |
| self.assertEqual( |
| getattr(self.errors, tracker_helpers.BLOCKING), |
| 'Cannot be blocking the same issue') |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| |
| def testParseBlockers_SameIssueDifferentProject(self): |
| """Adding different blocker issue should not modify the errors object.""" |
| post_data = {'id': '2', tracker_helpers.BLOCKING: 'testproj:2'} |
| |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testprojB', |
| tracker_helpers.BLOCKING) |
| self.assertEqual('testproj:2', parsed_blockers.entered_str) |
| self.assertEqual([100002], parsed_blockers.iids) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKING)) |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| |
| def testParseBlockers_Invalid(self): |
| """Input fields with invalid values should modify the errors object.""" |
| post_data = {tracker_helpers.BLOCKING: '2, foo', |
| tracker_helpers.BLOCKED_ON: '3, bar'} |
| |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKING) |
| self.assertEqual('2, foo', parsed_blockers.entered_str) |
| self.assertEqual([100002], parsed_blockers.iids) |
| self.assertEqual( |
| getattr(self.errors, tracker_helpers.BLOCKING), 'Invalid issue ID foo') |
| self.assertIsNone(getattr(self.errors, tracker_helpers.BLOCKED_ON)) |
| |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKED_ON) |
| self.assertEqual('3, bar', parsed_blockers.entered_str) |
| self.assertEqual([100003], parsed_blockers.iids) |
| self.assertEqual( |
| getattr(self.errors, tracker_helpers.BLOCKED_ON), |
| 'Invalid issue ID bar') |
| |
| def testParseBlockers_Dangling(self): |
| """A ref to a sanctioned projected should be allowed.""" |
| post_data = {'id': '2', tracker_helpers.BLOCKING: 'otherproj:2'} |
| real_codesite_projects = settings.recognized_codesite_projects |
| settings.recognized_codesite_projects = ['otherproj'] |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKING) |
| self.assertEqual('otherproj:2', parsed_blockers.entered_str) |
| self.assertEqual([('otherproj', 2)], parsed_blockers.dangling_refs) |
| settings.recognized_codesite_projects = real_codesite_projects |
| |
| def testParseBlockers_FederatedReferences(self): |
| """Should parse and return FedRefs.""" |
| post_data = {'id': '9', tracker_helpers.BLOCKING: '2, b/123, 3, b/789'} |
| parsed_blockers = tracker_helpers._ParseBlockers( |
| self.cnxn, post_data, self.services, self.errors, 'testproj', |
| tracker_helpers.BLOCKING) |
| self.assertEqual('2, b/123, 3, b/789', parsed_blockers.entered_str) |
| self.assertEqual([100002, 100003], parsed_blockers.iids) |
| self.assertEqual(['b/123', 'b/789'], parsed_blockers.federated_ref_strings) |
| |
| def testIsValidIssueOwner(self): |
| project = project_pb2.Project() |
| project.owner_ids.extend([1, 2]) |
| project.committer_ids.extend([3]) |
| project.contributor_ids.extend([4, 999]) |
| |
| valid, _ = tracker_helpers.IsValidIssueOwner( |
| 'fake cnxn', project, framework_constants.NO_USER_SPECIFIED, |
| self.services) |
| self.assertTrue(valid) |
| |
| valid, _ = tracker_helpers.IsValidIssueOwner( |
| 'fake cnxn', project, 1, |
| self.services) |
| self.assertTrue(valid) |
| valid, _ = tracker_helpers.IsValidIssueOwner( |
| 'fake cnxn', project, 2, |
| self.services) |
| self.assertTrue(valid) |
| valid, _ = tracker_helpers.IsValidIssueOwner( |
| 'fake cnxn', project, 3, |
| self.services) |
| self.assertTrue(valid) |
| valid, _ = tracker_helpers.IsValidIssueOwner( |
| 'fake cnxn', project, 4, |
| self.services) |
| self.assertTrue(valid) |
| |
| valid, _ = tracker_helpers.IsValidIssueOwner( |
| 'fake cnxn', project, 7, |
| self.services) |
| self.assertFalse(valid) |
| |
| valid, _ = tracker_helpers.IsValidIssueOwner( |
| 'fake cnxn', project, 999, |
| self.services) |
| self.assertFalse(valid) |
| |
| # MakeViewsForUsersInIssuesTest is tested in MakeViewsForUsersInIssuesTest. |
| |
| def testGetAllowedOpenedAndClosedIssues(self): |
| pass # TOOD(jrobbins): Write this test. |
| |
| def testFormatIssueListURL_JumpedToIssue(self): |
| """If we jumped to issue 123, the list is can=1&q=id-123.""" |
| config = tracker_pb2.ProjectIssueConfig() |
| path = '/p/proj/issues/detail?id=123&q=123' |
| mr = testing_helpers.MakeMonorailRequest( |
| path=path, headers={'Host': 'code.google.com'}) |
| mr.ComputeColSpec(config) |
| |
| absolute_base_url = 'http://code.google.com' |
| |
| url_1 = tracker_helpers.FormatIssueListURL(mr, config) |
| self.assertEqual( |
| '%s/p/proj/issues/list?can=1&%s&q=id%%3D123' % ( |
| absolute_base_url, self.default_colspec_param), |
| url_1) |
| |
| def testFormatIssueListURL_NoCurrentState(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| path = '/p/proj/issues/detail?id=123' |
| mr = testing_helpers.MakeMonorailRequest( |
| path=path, headers={'Host': 'code.google.com'}) |
| mr.ComputeColSpec(config) |
| |
| absolute_base_url = 'http://code.google.com' |
| |
| url_1 = tracker_helpers.FormatIssueListURL(mr, config) |
| self.assertEqual( |
| '%s/p/proj/issues/list?%s&q=' % ( |
| absolute_base_url, self.default_colspec_param), |
| url_1) |
| |
| url_2 = tracker_helpers.FormatIssueListURL( |
| mr, config, foo=123) |
| self.assertEqual( |
| '%s/p/proj/issues/list?%s&foo=123&q=' % ( |
| absolute_base_url, self.default_colspec_param), |
| url_2) |
| |
| url_3 = tracker_helpers.FormatIssueListURL( |
| mr, config, foo=123, bar='abc') |
| self.assertEqual( |
| '%s/p/proj/issues/list?bar=abc&%s&foo=123&q=' % ( |
| absolute_base_url, self.default_colspec_param), |
| url_3) |
| |
| url_4 = tracker_helpers.FormatIssueListURL( |
| mr, config, baz='escaped+encoded&and100% "safe"') |
| self.assertEqual( |
| '%s/p/proj/issues/list?' |
| 'baz=escaped%%2Bencoded%%26and100%%25%%20%%22safe%%22&%s&q=' % ( |
| absolute_base_url, self.default_colspec_param), |
| url_4) |
| |
| def testFormatIssueListURL_KeepCurrentState(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| path = '/p/proj/issues/detail?id=123&sort=aa&colspec=a b c&groupby=d' |
| mr = testing_helpers.MakeMonorailRequest( |
| path=path, headers={'Host': 'localhost:8080'}) |
| mr.ComputeColSpec(config) |
| |
| absolute_base_url = 'http://localhost:8080' |
| |
| url_1 = tracker_helpers.FormatIssueListURL(mr, config) |
| self.assertEqual( |
| '%s/p/proj/issues/list?colspec=a%%20b%%20c' |
| '&groupby=d&q=&sort=aa' % absolute_base_url, |
| url_1) |
| |
| url_2 = tracker_helpers.FormatIssueListURL( |
| mr, config, foo=123) |
| self.assertEqual( |
| '%s/p/proj/issues/list?' |
| 'colspec=a%%20b%%20c&foo=123&groupby=d&q=&sort=aa' % absolute_base_url, |
| url_2) |
| |
| url_3 = tracker_helpers.FormatIssueListURL( |
| mr, config, colspec='X Y Z') |
| self.assertEqual( |
| '%s/p/proj/issues/list?colspec=a%%20b%%20c' |
| '&groupby=d&q=&sort=aa' % absolute_base_url, |
| url_3) |
| |
| def testFormatRelativeIssueURL(self): |
| self.assertEqual( |
| '/p/proj/issues/attachment', |
| tracker_helpers.FormatRelativeIssueURL( |
| 'proj', urls.ISSUE_ATTACHMENT)) |
| |
| self.assertEqual( |
| '/p/proj/issues/detail?id=123', |
| tracker_helpers.FormatRelativeIssueURL( |
| 'proj', urls.ISSUE_DETAIL, id=123)) |
| |
| @mock.patch('google.appengine.api.app_identity.get_application_id') |
| def testFormatCrBugURL_Prod(self, mock_get_app_id): |
| mock_get_app_id.return_value = 'monorail-prod' |
| self.assertEqual( |
| 'https://crbug.com/proj/123', |
| tracker_helpers.FormatCrBugURL('proj', 123)) |
| self.assertEqual( |
| 'https://crbug.com/123456', |
| tracker_helpers.FormatCrBugURL('chromium', 123456)) |
| |
| @mock.patch('google.appengine.api.app_identity.get_application_id') |
| def testFormatCrBugURL_NonProd(self, mock_get_app_id): |
| mock_get_app_id.return_value = 'monorail-staging' |
| self.assertEqual( |
| '/p/proj/issues/detail?id=123', |
| tracker_helpers.FormatCrBugURL('proj', 123)) |
| self.assertEqual( |
| '/p/chromium/issues/detail?id=123456', |
| tracker_helpers.FormatCrBugURL('chromium', 123456)) |
| |
| @mock.patch('tracker.tracker_constants.ISSUE_ATTACHMENTS_QUOTA_HARD', 1) |
| def testComputeNewQuotaBytesUsed_ProjectQuota(self): |
| upload_1 = framework_helpers.AttachmentUpload( |
| 'matter not', 'three men make a tiger', 'matter not') |
| upload_2 = framework_helpers.AttachmentUpload( |
| 'matter not', 'chicken', 'matter not') |
| attachments = [upload_1, upload_2] |
| |
| project = fake.Project() |
| project.attachment_bytes_used = 10 |
| project.attachment_quota = project.attachment_bytes_used + len( |
| upload_1.contents + upload_2.contents) + 1 |
| |
| actual_new = tracker_helpers.ComputeNewQuotaBytesUsed(project, attachments) |
| expected_new = project.attachment_quota - 1 |
| self.assertEqual(actual_new, expected_new) |
| |
| upload_3 = framework_helpers.AttachmentUpload( |
| 'matter not', 'donut', 'matter not') |
| attachments.append(upload_3) |
| with self.assertRaises(exceptions.OverAttachmentQuota): |
| tracker_helpers.ComputeNewQuotaBytesUsed(project, attachments) |
| |
| @mock.patch( |
| 'tracker.tracker_constants.ISSUE_ATTACHMENTS_QUOTA_HARD', len('tiger')) |
| def testComputeNewQuotaBytesUsed_GeneralQuota(self): |
| upload_1 = framework_helpers.AttachmentUpload( |
| 'matter not', 'tiger', 'matter not') |
| attachments = [upload_1] |
| |
| project = fake.Project() |
| |
| actual_new = tracker_helpers.ComputeNewQuotaBytesUsed(project, attachments) |
| expected_new = len(upload_1.contents) |
| self.assertEqual(actual_new, expected_new) |
| |
| upload_2 = framework_helpers.AttachmentUpload( |
| 'matter not', 'donut', 'matter not') |
| attachments.append(upload_2) |
| with self.assertRaises(exceptions.OverAttachmentQuota): |
| tracker_helpers.ComputeNewQuotaBytesUsed(project, attachments) |
| |
| upload_3 = framework_helpers.AttachmentUpload( |
| 'matter not', 'donut', 'matter not') |
| attachments.append(upload_3) |
| with self.assertRaises(exceptions.OverAttachmentQuota): |
| tracker_helpers.ComputeNewQuotaBytesUsed(project, attachments) |
| |
| def testIsUnderSoftAttachmentQuota(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| # GetAllIssueProjects is tested in GetAllIssueProjectsTest. |
| |
| def testGetPermissionsInAllProjects(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| # FilterOutNonViewableIssues is tested in FilterOutNonViewableIssuesTest. |
| |
| def testMeansOpenInProject(self): |
| config = _MakeConfig() |
| |
| # ensure open means open |
| self.assertTrue(tracker_helpers.MeansOpenInProject('New', config)) |
| self.assertTrue(tracker_helpers.MeansOpenInProject('new', config)) |
| |
| # ensure an unrecognized status means open |
| self.assertTrue(tracker_helpers.MeansOpenInProject( |
| '_undefined_status_', config)) |
| |
| # ensure closed means closed |
| self.assertFalse(tracker_helpers.MeansOpenInProject('Old', config)) |
| self.assertFalse(tracker_helpers.MeansOpenInProject('old', config)) |
| self.assertFalse(tracker_helpers.MeansOpenInProject( |
| 'StatusThatWeDontUseAnymore', config)) |
| |
| def testIsNoisy(self): |
| self.assertTrue(tracker_helpers.IsNoisy(778, 320)) |
| self.assertFalse(tracker_helpers.IsNoisy(20, 500)) |
| self.assertFalse(tracker_helpers.IsNoisy(500, 20)) |
| self.assertFalse(tracker_helpers.IsNoisy(1, 1)) |
| |
| def testMergeCCsAndAddComment(self): |
| target_issue = fake.MakeTestIssue( |
| 789, 10, 'Target issue', 'New', 111) |
| source_issue = fake.MakeTestIssue( |
| 789, 100, 'Source issue', 'New', 222) |
| source_issue.cc_ids.append(111) |
| # Issue without owner |
| source_issue_2 = fake.MakeTestIssue( |
| 789, 101, 'Source issue 2', 'New', 0) |
| |
| self.services.issue.TestAddIssue(target_issue) |
| self.services.issue.TestAddIssue(source_issue) |
| self.services.issue.TestAddIssue(source_issue_2) |
| |
| # We copy this list so that it isn't updated by the test framework |
| initial_issue_comments = ( |
| self.services.issue.GetCommentsForIssue( |
| 'fake cnxn', target_issue.issue_id)[:]) |
| mr = testing_helpers.MakeMonorailRequest(user_info={'user_id': 111}) |
| |
| # Merging source into target should create a comment. |
| self.assertIsNotNone( |
| tracker_helpers.MergeCCsAndAddComment( |
| self.services, mr, source_issue, target_issue)) |
| updated_issue_comments = self.services.issue.GetCommentsForIssue( |
| 'fake cnxn', target_issue.issue_id) |
| for comment in initial_issue_comments: |
| self.assertIn(comment, updated_issue_comments) |
| self.assertEqual( |
| len(initial_issue_comments) + 1, len(updated_issue_comments)) |
| |
| # Merging source into target should add source's owner to target's CCs. |
| updated_target_issue = self.services.issue.GetIssueByLocalID( |
| 'fake cnxn', 789, 10) |
| self.assertIn(111, updated_target_issue.cc_ids) |
| self.assertIn(222, updated_target_issue.cc_ids) |
| |
| # Merging source 2 into target should make a comment, but not update CCs. |
| self.assertIsNotNone( |
| tracker_helpers.MergeCCsAndAddComment( |
| self.services, mr, source_issue_2, updated_target_issue)) |
| updated_target_issue = self.services.issue.GetIssueByLocalID( |
| 'fake cnxn', 789, 10) |
| self.assertNotIn(0, updated_target_issue.cc_ids) |
| |
| def testMergeCCsAndAddComment_RestrictedSourceIssue(self): |
| target_issue = fake.MakeTestIssue( |
| 789, 10, 'Target issue', 'New', 222) |
| target_issue_2 = fake.MakeTestIssue( |
| 789, 11, 'Target issue 2', 'New', 222) |
| source_issue = fake.MakeTestIssue( |
| 789, 100, 'Source issue', 'New', 111) |
| source_issue.cc_ids.append(111) |
| source_issue.labels.append('Restrict-View-Commit') |
| target_issue_2.labels.append('Restrict-View-Commit') |
| |
| self.services.issue.TestAddIssue(source_issue) |
| self.services.issue.TestAddIssue(target_issue) |
| self.services.issue.TestAddIssue(target_issue_2) |
| |
| # We copy this list so that it isn't updated by the test framework |
| initial_issue_comments = self.services.issue.GetCommentsForIssue( |
| 'fake cnxn', target_issue.issue_id)[:] |
| mr = testing_helpers.MakeMonorailRequest(user_info={'user_id': 111}) |
| self.assertIsNotNone( |
| tracker_helpers.MergeCCsAndAddComment( |
| self.services, mr, source_issue, target_issue)) |
| |
| # When the source is restricted, we update the target comments... |
| updated_issue_comments = self.services.issue.GetCommentsForIssue( |
| 'fake cnxn', target_issue.issue_id) |
| for comment in initial_issue_comments: |
| self.assertIn(comment, updated_issue_comments) |
| self.assertEqual( |
| len(initial_issue_comments) + 1, len(updated_issue_comments)) |
| # ...but not the target CCs... |
| updated_target_issue = self.services.issue.GetIssueByLocalID( |
| 'fake cnxn', 789, 10) |
| self.assertNotIn(111, updated_target_issue.cc_ids) |
| # ...unless both issues have the same restrictions. |
| self.assertIsNotNone( |
| tracker_helpers.MergeCCsAndAddComment( |
| self.services, mr, source_issue, target_issue_2)) |
| updated_target_issue_2 = self.services.issue.GetIssueByLocalID( |
| 'fake cnxn', 789, 11) |
| self.assertIn(111, updated_target_issue_2.cc_ids) |
| |
| def testMergeCCsAndAddCommentMultipleIssues(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| def testGetAttachmentIfAllowed(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| def testLabelsMaskedByFields(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| def testLabelsNotMaskedByFields(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| def testLookupComponentIDs(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| def testParsePostDataUsers(self): |
| pd_users = 'a@example.com, b@example.com' |
| |
| pd_users_ids, pd_users_str = tracker_helpers.ParsePostDataUsers( |
| self.cnxn, pd_users, self.services.user) |
| |
| self.assertEqual([1, 2], sorted(pd_users_ids)) |
| self.assertEqual('a@example.com, b@example.com', pd_users_str) |
| |
| def testParsePostDataUsers_Empty(self): |
| pd_users = '' |
| |
| pd_users_ids, pd_users_str = tracker_helpers.ParsePostDataUsers( |
| self.cnxn, pd_users, self.services.user) |
| |
| self.assertEqual([], sorted(pd_users_ids)) |
| self.assertEqual('', pd_users_str) |
| |
| def testFilterIssueTypes(self): |
| pass # TODO(jrobbins): Write this test. |
| |
| # ParseMergeFields is tested in IssueMergeTest. |
| # AddIssueStarrers is tested in IssueMergeTest.testMergeIssueStars(). |
| # IsMergeAllowed is tested in IssueMergeTest. |
| |
| def testPairDerivedValuesWithRuleExplanations_Nothing(self): |
| """Test we return nothing for an issue with no derived values.""" |
| proposed_issue = tracker_pb2.Issue() # No derived values. |
| traces = {} |
| derived_users_by_id = {} |
| actual = tracker_helpers.PairDerivedValuesWithRuleExplanations( |
| proposed_issue, traces, derived_users_by_id) |
| (derived_labels_and_why, derived_owner_and_why, |
| derived_cc_and_why, warnings_and_why, errors_and_why) = actual |
| self.assertEqual([], derived_labels_and_why) |
| self.assertEqual([], derived_owner_and_why) |
| self.assertEqual([], derived_cc_and_why) |
| self.assertEqual([], warnings_and_why) |
| self.assertEqual([], errors_and_why) |
| |
| def testPairDerivedValuesWithRuleExplanations_SomeValues(self): |
| """Test we return derived values and explanations for an issue.""" |
| proposed_issue = tracker_pb2.Issue( |
| derived_owner_id=111, derived_cc_ids=[222, 333], |
| derived_labels=['aaa', 'zzz'], |
| derived_warnings=['Watch out'], |
| derived_errors=['Status Assigned requires an owner']) |
| traces = { |
| (tracker_pb2.FieldID.OWNER, 111): 'explain 1', |
| (tracker_pb2.FieldID.CC, 222): 'explain 2', |
| (tracker_pb2.FieldID.CC, 333): 'explain 3', |
| (tracker_pb2.FieldID.LABELS, 'aaa'): 'explain 4', |
| (tracker_pb2.FieldID.WARNING, 'Watch out'): 'explain 6', |
| (tracker_pb2.FieldID.ERROR, |
| 'Status Assigned requires an owner'): 'explain 7', |
| # There can be extra traces that are not used. |
| (tracker_pb2.FieldID.LABELS, 'bbb'): 'explain 5', |
| # If there is no trace for some derived value, why is None. |
| } |
| derived_users_by_id = { |
| 111: testing_helpers.Blank(display_name='one@example.com'), |
| 222: testing_helpers.Blank(display_name='two@example.com'), |
| 333: testing_helpers.Blank(display_name='three@example.com'), |
| } |
| actual = tracker_helpers.PairDerivedValuesWithRuleExplanations( |
| proposed_issue, traces, derived_users_by_id) |
| (derived_labels_and_why, derived_owner_and_why, |
| derived_cc_and_why, warnings_and_why, errors_and_why) = actual |
| self.assertEqual([ |
| {'value': 'aaa', 'why': 'explain 4'}, |
| {'value': 'zzz', 'why': None}, |
| ], derived_labels_and_why) |
| self.assertEqual([ |
| {'value': 'one@example.com', 'why': 'explain 1'}, |
| ], derived_owner_and_why) |
| self.assertEqual([ |
| {'value': 'two@example.com', 'why': 'explain 2'}, |
| {'value': 'three@example.com', 'why': 'explain 3'}, |
| ], derived_cc_and_why) |
| self.assertEqual([ |
| {'value': 'Watch out', 'why': 'explain 6'}, |
| ], warnings_and_why) |
| self.assertEqual([ |
| {'value': 'Status Assigned requires an owner', 'why': 'explain 7'}, |
| ], errors_and_why) |
| |
| |
| class MakeViewsForUsersInIssuesTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.issue1 = _Issue('proj', 1) |
| self.issue1.owner_id = 1001 |
| self.issue1.reporter_id = 1002 |
| |
| self.issue2 = _Issue('proj', 2) |
| self.issue2.owner_id = 2001 |
| self.issue2.reporter_id = 2002 |
| self.issue2.cc_ids.extend([1, 1001, 1002, 1003]) |
| |
| self.issue3 = _Issue('proj', 3) |
| self.issue3.owner_id = 1001 |
| self.issue3.reporter_id = 3002 |
| |
| self.user = fake.UserService() |
| for user_id in [1, 1001, 1002, 1003, 2001, 2002, 3002]: |
| self.user.TestAddUser( |
| 'test%d' % user_id, user_id, add_user=True) |
| |
| def testMakeViewsForUsersInIssues(self): |
| issue_list = [self.issue1, self.issue2, self.issue3] |
| users_by_id = tracker_helpers.MakeViewsForUsersInIssues( |
| 'fake cnxn', issue_list, self.user) |
| self.assertItemsEqual([0, 1, 1001, 1002, 1003, 2001, 2002, 3002], |
| list(users_by_id.keys())) |
| for user_id in [1001, 1002, 1003, 2001]: |
| self.assertEqual(users_by_id[user_id].user_id, user_id) |
| |
| def testMakeViewsForUsersInIssuesOmittingSome(self): |
| issue_list = [self.issue1, self.issue2, self.issue3] |
| users_by_id = tracker_helpers.MakeViewsForUsersInIssues( |
| 'fake cnxn', issue_list, self.user, omit_ids=[1001, 1003]) |
| self.assertItemsEqual([0, 1, 1002, 2001, 2002, 3002], |
| list(users_by_id.keys())) |
| for user_id in [1002, 2001, 2002, 3002]: |
| self.assertEqual(users_by_id[user_id].user_id, user_id) |
| |
| def testMakeViewsForUsersInIssuesEmpty(self): |
| issue_list = [] |
| users_by_id = tracker_helpers.MakeViewsForUsersInIssues( |
| 'fake cnxn', issue_list, self.user) |
| self.assertItemsEqual([], list(users_by_id.keys())) |
| |
| |
| class GetAllIssueProjectsTest(unittest.TestCase): |
| issue_x_1 = tracker_pb2.Issue() |
| issue_x_1.project_id = 789 |
| issue_x_1.local_id = 1 |
| issue_x_1.reporter_id = 1002 |
| |
| issue_x_2 = tracker_pb2.Issue() |
| issue_x_2.project_id = 789 |
| issue_x_2.local_id = 2 |
| issue_x_2.reporter_id = 2002 |
| |
| issue_y_1 = tracker_pb2.Issue() |
| issue_y_1.project_id = 678 |
| issue_y_1.local_id = 1 |
| issue_y_1.reporter_id = 2002 |
| |
| def setUp(self): |
| self.project_service = fake.ProjectService() |
| self.project_service.TestAddProject('proj-x', project_id=789) |
| self.project_service.TestAddProject('proj-y', project_id=678) |
| self.cnxn = 'fake connection' |
| |
| def testGetAllIssueProjects_Empty(self): |
| self.assertEqual( |
| {}, tracker_helpers.GetAllIssueProjects( |
| self.cnxn, [], self.project_service)) |
| |
| def testGetAllIssueProjects_Normal(self): |
| self.assertEqual( |
| {789: self.project_service.GetProjectByName(self.cnxn, 'proj-x')}, |
| tracker_helpers.GetAllIssueProjects( |
| self.cnxn, [self.issue_x_1, self.issue_x_2], self.project_service)) |
| self.assertEqual( |
| {789: self.project_service.GetProjectByName(self.cnxn, 'proj-x'), |
| 678: self.project_service.GetProjectByName(self.cnxn, 'proj-y')}, |
| tracker_helpers.GetAllIssueProjects( |
| self.cnxn, [self.issue_x_1, self.issue_x_2, self.issue_y_1], |
| self.project_service)) |
| |
| |
| class FilterOutNonViewableIssuesTest(unittest.TestCase): |
| owner_id = 111 |
| committer_id = 222 |
| nonmember_1_id = 1002 |
| nonmember_2_id = 2002 |
| nonmember_3_id = 3002 |
| |
| issue1 = tracker_pb2.Issue() |
| issue1.project_name = 'proj' |
| issue1.project_id = 789 |
| issue1.local_id = 1 |
| issue1.reporter_id = nonmember_1_id |
| |
| issue2 = tracker_pb2.Issue() |
| issue2.project_name = 'proj' |
| issue2.project_id = 789 |
| issue2.local_id = 2 |
| issue2.reporter_id = nonmember_2_id |
| issue2.labels.extend(['foo', 'bar']) |
| |
| issue3 = tracker_pb2.Issue() |
| issue3.project_name = 'proj' |
| issue3.project_id = 789 |
| issue3.local_id = 3 |
| issue3.reporter_id = nonmember_3_id |
| issue3.labels.extend(['restrict-view-commit']) |
| |
| issue4 = tracker_pb2.Issue() |
| issue4.project_name = 'proj' |
| issue4.project_id = 789 |
| issue4.local_id = 4 |
| issue4.reporter_id = nonmember_3_id |
| issue4.labels.extend(['Foo', 'Restrict-View-Commit']) |
| |
| def setUp(self): |
| self.user = user_pb2.User() |
| self.project = self.MakeProject(project_pb2.ProjectState.LIVE) |
| self.config = tracker_bizobj.MakeDefaultProjectIssueConfig( |
| self.project.project_id) |
| self.project_dict = {self.project.project_id: self.project} |
| self.config_dict = {self.config.project_id: self.config} |
| |
| def MakeProject(self, state): |
| p = project_pb2.Project( |
| project_id=789, project_name='proj', state=state, |
| owner_ids=[self.owner_id], committer_ids=[self.committer_id]) |
| return p |
| |
| def testFilterOutNonViewableIssues_Member(self): |
| # perms will be permissions.COMMITTER_ACTIVE_PERMISSIONSET |
| filtered_issues = tracker_helpers.FilterOutNonViewableIssues( |
| {self.committer_id}, self.user, self.project_dict, |
| self.config_dict, |
| [self.issue1, self.issue2, self.issue3, self.issue4]) |
| self.assertListEqual([1, 2, 3, 4], |
| [issue.local_id for issue in filtered_issues]) |
| |
| def testFilterOutNonViewableIssues_Owner(self): |
| # perms will be permissions.OWNER_ACTIVE_PERMISSIONSET |
| filtered_issues = tracker_helpers.FilterOutNonViewableIssues( |
| {self.owner_id}, self.user, self.project_dict, self.config_dict, |
| [self.issue1, self.issue2, self.issue3, self.issue4]) |
| self.assertListEqual([1, 2, 3, 4], |
| [issue.local_id for issue in filtered_issues]) |
| |
| def testFilterOutNonViewableIssues_Empty(self): |
| # perms will be permissions.COMMITTER_ACTIVE_PERMISSIONSET |
| filtered_issues = tracker_helpers.FilterOutNonViewableIssues( |
| {self.committer_id}, self.user, self.project_dict, |
| self.config_dict, []) |
| self.assertListEqual([], filtered_issues) |
| |
| def testFilterOutNonViewableIssues_NonMember(self): |
| # perms will be permissions.READ_ONLY_PERMISSIONSET |
| filtered_issues = tracker_helpers.FilterOutNonViewableIssues( |
| {self.nonmember_1_id}, self.user, self.project_dict, |
| self.config_dict, [self.issue1, self.issue2, self.issue3, self.issue4]) |
| self.assertListEqual([1, 2], |
| [issue.local_id for issue in filtered_issues]) |
| |
| def testFilterOutNonViewableIssues_Reporter(self): |
| # perms will be permissions.READ_ONLY_PERMISSIONSET |
| filtered_issues = tracker_helpers.FilterOutNonViewableIssues( |
| {self.nonmember_3_id}, self.user, self.project_dict, |
| self.config_dict, [self.issue1, self.issue2, self.issue3, self.issue4]) |
| self.assertListEqual([1, 2, 3, 4], |
| [issue.local_id for issue in filtered_issues]) |
| |
| |
| class IssueMergeTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.cnxn = 'fake cnxn' |
| self.services = service_manager.Services( |
| config=fake.ConfigService(), |
| issue=fake.IssueService(), |
| user=fake.UserService(), |
| project=fake.ProjectService(), |
| issue_star=fake.IssueStarService(), |
| spam=fake.SpamService() |
| ) |
| self.project = self.services.project.TestAddProject('proj', project_id=987) |
| self.config = tracker_bizobj.MakeDefaultProjectIssueConfig( |
| self.project.project_id) |
| self.project_dict = {self.project.project_id: self.project} |
| self.config_dict = {self.config.project_id: self.config} |
| |
| def testParseMergeFields_NotSpecified(self): |
| issue = fake.MakeTestIssue(987, 1, 'summary', 'New', 111) |
| errors = template_helpers.EZTError() |
| post_data = {} |
| |
| text, merge_into_issue = tracker_helpers.ParseMergeFields( |
| self.cnxn, None, 'proj', post_data, 'New', self.config, issue, errors) |
| self.assertEqual('', text) |
| self.assertEqual(None, merge_into_issue) |
| |
| text, merge_into_issue = tracker_helpers.ParseMergeFields( |
| self.cnxn, None, 'proj', post_data, 'Duplicate', self.config, issue, |
| errors) |
| self.assertEqual('', text) |
| self.assertTrue(errors.merge_into_id) |
| self.assertEqual(None, merge_into_issue) |
| |
| def testParseMergeFields_WrongStatus(self): |
| issue = fake.MakeTestIssue(987, 1, 'summary', 'New', 111) |
| errors = template_helpers.EZTError() |
| post_data = {'merge_into': '12'} |
| |
| text, merge_into_issue = tracker_helpers.ParseMergeFields( |
| self.cnxn, None, 'proj', post_data, 'New', self.config, issue, errors) |
| self.assertEqual('', text) |
| self.assertEqual(None, merge_into_issue) |
| |
| def testParseMergeFields_NoSuchIssue(self): |
| issue = fake.MakeTestIssue(987, 1, 'summary', 'New', 111) |
| issue.merged_into = 12 |
| errors = template_helpers.EZTError() |
| post_data = {'merge_into': '12'} |
| |
| text, merge_into_issue = tracker_helpers.ParseMergeFields( |
| self.cnxn, self.services, 'proj', post_data, 'Duplicate', |
| self.config, issue, errors) |
| self.assertEqual('12', text) |
| self.assertEqual(None, merge_into_issue) |
| |
| def testParseMergeFields_DontSelfMerge(self): |
| issue = fake.MakeTestIssue(987, 1, 'summary', 'New', 111) |
| errors = template_helpers.EZTError() |
| post_data = {'merge_into': '1'} |
| |
| text, merge_into_issue = tracker_helpers.ParseMergeFields( |
| self.cnxn, self.services, 'proj', post_data, 'Duplicate', self.config, |
| issue, errors) |
| self.assertEqual('1', text) |
| self.assertEqual(None, merge_into_issue) |
| self.assertEqual('Cannot merge issue into itself', errors.merge_into_id) |
| |
| def testParseMergeFields_NewIssueToMerge(self): |
| merged_issue = fake.MakeTestIssue( |
| self.project.project_id, |
| 1, |
| 'unused_summary', |
| 'unused_status', |
| 111, |
| reporter_id=111) |
| self.services.issue.TestAddIssue(merged_issue) |
| mergee_issue = fake.MakeTestIssue( |
| self.project.project_id, |
| 2, |
| 'unused_summary', |
| 'unused_status', |
| 111, |
| reporter_id=111) |
| self.services.issue.TestAddIssue(mergee_issue) |
| |
| errors = template_helpers.EZTError() |
| post_data = {'merge_into': str(mergee_issue.local_id)} |
| |
| text, merge_into_issue = tracker_helpers.ParseMergeFields( |
| self.cnxn, self.services, 'proj', post_data, 'Duplicate', self.config, |
| merged_issue, errors) |
| self.assertEqual(str(mergee_issue.local_id), text) |
| self.assertEqual(mergee_issue, merge_into_issue) |
| |
| def testIsMergeAllowed(self): |
| mr = testing_helpers.MakeMonorailRequest() |
| issue = fake.MakeTestIssue(987, 1, 'summary', 'New', 111) |
| issue.project_name = self.project.project_name |
| |
| for (perm_set, expected_merge_allowed) in ( |
| (permissions.READ_ONLY_PERMISSIONSET, False), |
| (permissions.COMMITTER_INACTIVE_PERMISSIONSET, False), |
| (permissions.COMMITTER_ACTIVE_PERMISSIONSET, True), |
| (permissions.OWNER_ACTIVE_PERMISSIONSET, True)): |
| mr.perms = perm_set |
| merge_allowed = tracker_helpers.IsMergeAllowed(issue, mr, self.services) |
| self.assertEqual(expected_merge_allowed, merge_allowed) |
| |
| def testMergeIssueStars(self): |
| mr = testing_helpers.MakeMonorailRequest() |
| mr.project_name = self.project.project_name |
| mr.project = self.project |
| |
| config = self.services.config.GetProjectConfig( |
| self.cnxn, self.project.project_id) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 1, 1, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 1, 2, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 1, 3, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 3, 3, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 3, 6, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 2, 3, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 2, 4, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, config, 2, 5, True) |
| |
| new_starrers = tracker_helpers.GetNewIssueStarrers( |
| self.cnxn, self.services, [1, 3], 2) |
| self.assertItemsEqual(new_starrers, [1, 2, 6]) |
| tracker_helpers.AddIssueStarrers( |
| self.cnxn, self.services, mr, 2, self.project, new_starrers) |
| issue_2_starrers = self.services.issue_star.LookupItemStarrers( |
| self.cnxn, 2) |
| # XXX(jrobbins): these tests incorrectly mix local IDs with IIDs. |
| self.assertItemsEqual([1, 2, 3, 4, 5, 6], issue_2_starrers) |
| |
| |
| class MergeLinkedMembersTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.cnxn = 'fake cnxn' |
| self.services = service_manager.Services( |
| user=fake.UserService()) |
| self.user1 = self.services.user.TestAddUser('one@example.com', 111) |
| self.user2 = self.services.user.TestAddUser('two@example.com', 222) |
| |
| def testNoLinkedAccounts(self): |
| """When no candidate accounts are linked, they are all returned.""" |
| actual = tracker_helpers._MergeLinkedMembers( |
| self.cnxn, self.services.user, [111, 222]) |
| self.assertEqual([111, 222], actual) |
| |
| def testSomeLinkedButNoMasking(self): |
| """If an account has linked accounts, but they are not here, keep it.""" |
| self.user1.linked_child_ids = [999] |
| self.user2.linked_parent_id = 999 |
| actual = tracker_helpers._MergeLinkedMembers( |
| self.cnxn, self.services.user, [111, 222]) |
| self.assertEqual([111, 222], actual) |
| |
| def testParentMasksChild(self): |
| """When two accounts linked, only the parent is returned.""" |
| self.user2.linked_parent_id = 111 |
| actual = tracker_helpers._MergeLinkedMembers( |
| self.cnxn, self.services.user, [111, 222]) |
| self.assertEqual([111], actual) |
| |
| |
| class FilterMemberDataTest(unittest.TestCase): |
| |
| def setUp(self): |
| services = service_manager.Services( |
| project=fake.ProjectService(), |
| config=fake.ConfigService(), |
| issue=fake.IssueService(), |
| user=fake.UserService()) |
| self.owner_email = 'owner@dom.com' |
| self.committer_email = 'commit@dom.com' |
| self.contributor_email = 'contrib@dom.com' |
| self.indirect_member_email = 'ind@dom.com' |
| self.all_emails = [self.owner_email, self.committer_email, |
| self.contributor_email, self.indirect_member_email] |
| self.project = services.project.TestAddProject('proj') |
| |
| def DoFiltering(self, perms, unsigned_user=False): |
| mr = testing_helpers.MakeMonorailRequest( |
| project=self.project, perms=perms) |
| if not unsigned_user: |
| mr.auth.user_id = 111 |
| mr.auth.user_view = testing_helpers.Blank(domain='jrobbins.org') |
| return tracker_helpers._FilterMemberData( |
| mr, [self.owner_email], [self.committer_email], |
| [self.contributor_email], [self.indirect_member_email], mr.project) |
| |
| def testUnsignedUser_NormalProject(self): |
| visible_members = self.DoFiltering( |
| permissions.READ_ONLY_PERMISSIONSET, unsigned_user=True) |
| self.assertItemsEqual( |
| [self.owner_email, self.committer_email, self.contributor_email, |
| self.indirect_member_email], |
| visible_members) |
| |
| def testUnsignedUser_RestrictedProject(self): |
| self.project.only_owners_see_contributors = True |
| visible_members = self.DoFiltering( |
| permissions.READ_ONLY_PERMISSIONSET, unsigned_user=True) |
| self.assertItemsEqual( |
| [self.owner_email, self.committer_email, self.indirect_member_email], |
| visible_members) |
| |
| def testOwnersAndAdminsCanSeeAll_NormalProject(self): |
| visible_members = self.DoFiltering( |
| permissions.OWNER_ACTIVE_PERMISSIONSET) |
| self.assertItemsEqual(self.all_emails, visible_members) |
| |
| visible_members = self.DoFiltering( |
| permissions.ADMIN_PERMISSIONSET) |
| self.assertItemsEqual(self.all_emails, visible_members) |
| |
| def testOwnersAndAdminsCanSeeAll_HubAndSpoke(self): |
| self.project.only_owners_see_contributors = True |
| |
| visible_members = self.DoFiltering( |
| permissions.OWNER_ACTIVE_PERMISSIONSET) |
| self.assertItemsEqual(self.all_emails, visible_members) |
| |
| visible_members = self.DoFiltering( |
| permissions.ADMIN_PERMISSIONSET) |
| self.assertItemsEqual(self.all_emails, visible_members) |
| |
| visible_members = self.DoFiltering( |
| permissions.COMMITTER_ACTIVE_PERMISSIONSET) |
| self.assertItemsEqual(self.all_emails, visible_members) |
| |
| def testNonOwnersCanSeeAll_NormalProject(self): |
| visible_members = self.DoFiltering( |
| permissions.COMMITTER_ACTIVE_PERMISSIONSET) |
| self.assertItemsEqual(self.all_emails, visible_members) |
| |
| visible_members = self.DoFiltering( |
| permissions.CONTRIBUTOR_ACTIVE_PERMISSIONSET) |
| self.assertItemsEqual(self.all_emails, visible_members) |
| |
| def testCommittersSeeOnlySameDomain_HubAndSpoke(self): |
| self.project.only_owners_see_contributors = True |
| |
| visible_members = self.DoFiltering( |
| permissions.CONTRIBUTOR_ACTIVE_PERMISSIONSET) |
| self.assertItemsEqual( |
| [self.owner_email, self.committer_email, self.indirect_member_email], |
| visible_members) |
| |
| |
| class GetLabelOptionsTest(unittest.TestCase): |
| |
| @mock.patch('tracker.tracker_helpers.LabelsNotMaskedByFields') |
| def testGetLabelOptions(self, mockLabelsNotMaskedByFields): |
| mockLabelsNotMaskedByFields.return_value = [] |
| config = tracker_pb2.ProjectIssueConfig() |
| custom_perms = [] |
| actual = tracker_helpers.GetLabelOptions(config, custom_perms) |
| expected = [ |
| {'doc': 'Only users who can edit the issue may access it', |
| 'name': 'Restrict-View-EditIssue'}, |
| {'doc': 'Only users who can edit the issue may add comments', |
| 'name': 'Restrict-AddIssueComment-EditIssue'}, |
| {'doc': 'Custom permission CoreTeam is needed to access', |
| 'name': 'Restrict-View-CoreTeam'} |
| ] |
| self.assertEqual(expected, actual) |
| |
| def testBuildRestrictionChoices(self): |
| choices = tracker_helpers._BuildRestrictionChoices([], [], []) |
| self.assertEqual([], choices) |
| |
| choices = tracker_helpers._BuildRestrictionChoices( |
| [], ['Hop', 'Jump'], []) |
| self.assertEqual([], choices) |
| |
| freq = [('View', 'B', 'You need permission B to do anything'), |
| ('A', 'B', 'You need B to use A')] |
| choices = tracker_helpers._BuildRestrictionChoices(freq, [], []) |
| expected = [dict(name='Restrict-View-B', |
| doc='You need permission B to do anything'), |
| dict(name='Restrict-A-B', |
| doc='You need B to use A')] |
| self.assertListEqual(expected, choices) |
| |
| extra_perms = ['Over18', 'Over21'] |
| choices = tracker_helpers._BuildRestrictionChoices( |
| [], ['Drink', 'Smoke'], extra_perms) |
| expected = [dict(name='Restrict-Drink-Over18', |
| doc='Permission Over18 needed to use Drink'), |
| dict(name='Restrict-Drink-Over21', |
| doc='Permission Over21 needed to use Drink'), |
| dict(name='Restrict-Smoke-Over18', |
| doc='Permission Over18 needed to use Smoke'), |
| dict(name='Restrict-Smoke-Over21', |
| doc='Permission Over21 needed to use Smoke')] |
| self.assertListEqual(expected, choices) |
| |
| |
| class FilterKeptAttachmentsTest(unittest.TestCase): |
| def testFilterKeptAttachments(self): |
| comments = [ |
| tracker_pb2.IssueComment( |
| is_description=True, |
| attachments=[tracker_pb2.Attachment(attachment_id=1)]), |
| tracker_pb2.IssueComment(), |
| tracker_pb2.IssueComment( |
| is_description=True, |
| attachments=[ |
| tracker_pb2.Attachment(attachment_id=2), |
| tracker_pb2.Attachment(attachment_id=3)]), |
| tracker_pb2.IssueComment(), |
| tracker_pb2.IssueComment( |
| approval_id=24, |
| is_description=True, |
| attachments=[tracker_pb2.Attachment(attachment_id=4)])] |
| |
| filtered = tracker_helpers.FilterKeptAttachments( |
| True, [1, 2, 3, 4], comments, None) |
| self.assertEqual([2, 3], filtered) |
| |
| def testApprovalDescription(self): |
| comments = [ |
| tracker_pb2.IssueComment( |
| is_description=True, |
| attachments=[tracker_pb2.Attachment(attachment_id=1)]), |
| tracker_pb2.IssueComment(), |
| tracker_pb2.IssueComment( |
| is_description=True, |
| attachments=[ |
| tracker_pb2.Attachment(attachment_id=2), |
| tracker_pb2.Attachment(attachment_id=3)]), |
| tracker_pb2.IssueComment(), |
| tracker_pb2.IssueComment( |
| approval_id=24, |
| is_description=True, |
| attachments=[tracker_pb2.Attachment(attachment_id=4)])] |
| |
| filtered = tracker_helpers.FilterKeptAttachments( |
| True, [1, 2, 3, 4], comments, 24) |
| self.assertEqual([4], filtered) |
| |
| def testNotAnIssueDescription(self): |
| comments = [ |
| tracker_pb2.IssueComment( |
| is_description=True, |
| attachments=[tracker_pb2.Attachment(attachment_id=1)]), |
| tracker_pb2.IssueComment(), |
| tracker_pb2.IssueComment( |
| is_description=True, |
| attachments=[ |
| tracker_pb2.Attachment(attachment_id=2), |
| tracker_pb2.Attachment(attachment_id=3)]), |
| tracker_pb2.IssueComment(), |
| tracker_pb2.IssueComment( |
| approval_id=24, |
| is_description=True, |
| attachments=[tracker_pb2.Attachment(attachment_id=4)])] |
| |
| filtered = tracker_helpers.FilterKeptAttachments( |
| False, [1, 2, 3, 4], comments, None) |
| self.assertIsNone(filtered) |
| |
| def testNoDescriptionsInComments(self): |
| comments = [ |
| tracker_pb2.IssueComment(), |
| tracker_pb2.IssueComment()] |
| |
| filtered = tracker_helpers.FilterKeptAttachments( |
| True, [1, 2, 3, 4], comments, None) |
| self.assertEqual([], filtered) |
| |
| def testNoComments(self): |
| filtered = tracker_helpers.FilterKeptAttachments( |
| True, [1, 2, 3, 4], [], None) |
| self.assertEqual([], filtered) |
| |
| |
| class EnumFieldHelpersTest(unittest.TestCase): |
| |
| def test_GetEnumFieldValuesAndDocstrings(self): |
| """We can get all choices for an enum field""" |
| fd = tracker_pb2.FieldDef( |
| field_id=123, |
| project_id=1, |
| field_name='yellow', |
| field_type=tracker_pb2.FieldTypes.ENUM_TYPE) |
| ld_1 = tracker_pb2.LabelDef( |
| label='yellow-submarine', label_docstring='ld_1_docstring') |
| ld_2 = tracker_pb2.LabelDef( |
| label='yellow-tisket', label_docstring='ld_2_docstring') |
| ld_3 = tracker_pb2.LabelDef( |
| label='yellow-basket', label_docstring='ld_3_docstring') |
| ld_4 = tracker_pb2.LabelDef( |
| label='yellow', label_docstring='ld_4_docstring') |
| ld_5 = tracker_pb2.LabelDef( |
| label='not-yellow', label_docstring='ld_5_docstring') |
| ld_6 = tracker_pb2.LabelDef( |
| label='yellow-tasket', |
| label_docstring='ld_6_docstring', |
| deprecated=True) |
| config = tracker_pb2.ProjectIssueConfig( |
| default_template_for_developers=1, |
| default_template_for_users=2, |
| well_known_labels=[ld_1, ld_2, ld_3, ld_4, ld_5, ld_6]) |
| actual = tracker_helpers._GetEnumFieldValuesAndDocstrings(fd, config) |
| # Expect to omit labels `yellow` and `not-yellow` due to prefix mismatch |
| # Also expect to omit label `yellow-tasket` because it's deprecated |
| expected = [ |
| ('submarine', 'ld_1_docstring'), ('tisket', 'ld_2_docstring'), |
| ('basket', 'ld_3_docstring') |
| ] |
| self.assertEqual(expected, actual) |
| |
| |
| class CreateIssueHelpersTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.services = service_manager.Services( |
| project=fake.ProjectService(), |
| config=fake.ConfigService(), |
| issue=fake.IssueService(), |
| user=fake.UserService(), |
| usergroup=fake.UserGroupService()) |
| self.cnxn = 'fake cnxn' |
| |
| self.project_member = self.services.user.TestAddUser( |
| 'user_1@example.com', 111) |
| self.project_group_member = self.services.user.TestAddUser( |
| 'group@example.com', 999) |
| self.project = self.services.project.TestAddProject( |
| 'proj', |
| project_id=789, |
| committer_ids=[ |
| self.project_member.user_id, self.project_group_member.user_id |
| ]) |
| self.no_project_user = self.services.user.TestAddUser( |
| 'user_2@example.com', 222) |
| self.config = fake.MakeTestConfig(self.project.project_id, [], []) |
| self.int_fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, '', False, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.int_fd.max_value = 999 |
| self.config.field_defs = [self.int_fd] |
| self.status_1 = tracker_pb2.StatusDef( |
| status='New', means_open=True, status_docstring='status_1 docstring') |
| self.config.well_known_statuses = [self.status_1] |
| self.component_def_1 = tracker_pb2.ComponentDef( |
| component_id=1, path='compFOO') |
| self.component_def_2 = tracker_pb2.ComponentDef( |
| component_id=2, path='deprecated', deprecated=True) |
| self.config.component_defs = [self.component_def_1, self.component_def_2] |
| self.services.config.StoreConfig('cnxn', self.config) |
| self.services.usergroup.TestAddGroupSettings(999, 'group@example.com') |
| |
| def testAssertValidIssueForCreate_Valid(self): |
| input_issue = tracker_pb2.Issue( |
| summary='sum', |
| status='New', |
| owner_id=111, |
| project_id=789, |
| component_ids=[1], |
| cc_ids=[999]) |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| |
| def testAssertValidIssueForCreate_ValidatesOwner(self): |
| input_issue = tracker_pb2.Issue( |
| summary='sum', status='New', owner_id=222, project_id=789) |
| with self.assertRaisesRegexp(exceptions.InputException, |
| 'Issue owner must be a project member'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| input_issue.owner_id = 333 |
| with self.assertRaisesRegexp(exceptions.InputException, |
| 'Issue owner user ID not found'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| input_issue.owner_id = 999 |
| with self.assertRaisesRegexp(exceptions.InputException, |
| 'Issue owner cannot be a user group'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| |
| def testAssertValidIssueForCreate_ValidatesSummary(self): |
| input_issue = tracker_pb2.Issue( |
| summary='', status='New', owner_id=111, project_id=789) |
| with self.assertRaisesRegexp(exceptions.InputException, |
| 'Summary is required'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| input_issue.summary = ' ' |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| |
| def testAssertValidIssueForCreate_ValidatesDescription(self): |
| input_issue = tracker_pb2.Issue( |
| summary='sum', status='New', owner_id=111, project_id=789) |
| with self.assertRaisesRegexp(exceptions.InputException, |
| 'Description is required'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, '') |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, ' ') |
| |
| def testAssertValidIssueForCreate_ValidatesFieldDef(self): |
| fv = tracker_bizobj.MakeFieldValue( |
| self.int_fd.field_id, 1000, None, None, None, None, False) |
| input_issue = tracker_pb2.Issue( |
| summary='sum', |
| status='New', |
| owner_id=111, |
| project_id=789, |
| field_values=[fv]) |
| with self.assertRaises(exceptions.InputException): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| |
| def testAssertValidIssueForCreate_ValidatesStatus(self): |
| input_issue = tracker_pb2.Issue( |
| summary='sum', status='DNE_status', owner_id=111, project_id=789) |
| |
| def mock_status_lookup(*_args, **_kwargs): |
| return None |
| |
| self.services.config.LookupStatusID = mock_status_lookup |
| with self.assertRaisesRegexp(exceptions.InputException, |
| 'Undefined status: DNE_status'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| |
| def testAssertValidIssueForCreate_ValidatesComponents(self): |
| # Tests an undefined component. |
| input_issue = tracker_pb2.Issue( |
| summary='', |
| status='New', |
| owner_id=111, |
| project_id=789, |
| component_ids=[3]) |
| with self.assertRaisesRegexp( |
| exceptions.InputException, |
| 'Undefined or deprecated component with id: 3'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| |
| # Tests a deprecated component. |
| input_issue = tracker_pb2.Issue( |
| summary='', |
| status='New', |
| owner_id=111, |
| project_id=789, |
| component_ids=[self.component_def_2.component_id]) |
| with self.assertRaisesRegexp( |
| exceptions.InputException, |
| 'Undefined or deprecated component with id: 2'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| |
| def testAssertValidIssueForCreate_ValidatesUsers(self): |
| user_fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, '', False, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.services.config.TestAddFieldDef(user_fd) |
| |
| input_issue = tracker_pb2.Issue( |
| summary='sum', |
| status='New', |
| owner_id=111, |
| project_id=789, |
| cc_ids=[123], |
| field_values=[ |
| tracker_bizobj.MakeFieldValue( |
| user_fd.field_id, None, None, 124, None, None, False) |
| ]) |
| copied_issue = copy.deepcopy(input_issue) |
| with self.assertRaisesRegexp(exceptions.InputException, |
| r'users/123: .+\nusers/124: .+'): |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| self.assertEqual(input_issue, copied_issue) |
| |
| self.services.user.TestAddUser('a@test.com', 123) |
| self.services.user.TestAddUser('a@test.com', 124) |
| tracker_helpers.AssertValidIssueForCreate( |
| self.cnxn, self.services, input_issue, 'nonempty description') |
| self.assertEqual(input_issue, copied_issue) |
| |
| |
| class ModifyIssuesHelpersTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.services = service_manager.Services( |
| project=fake.ProjectService(), |
| config=fake.ConfigService(), |
| issue=fake.IssueService(), |
| issue_star=fake.IssueStarService(), |
| user=fake.UserService(), |
| usergroup=fake.UserGroupService()) |
| self.cnxn = 'fake cnxn' |
| |
| self.project_member = self.services.user.TestAddUser( |
| 'user_1@example.com', 111) |
| self.project = self.services.project.TestAddProject( |
| 'proj', project_id=789, committer_ids=[self.project_member.user_id]) |
| self.no_project_user = self.services.user.TestAddUser( |
| 'user_2@example.com', 222) |
| |
| self.config = fake.MakeTestConfig(self.project.project_id, [], []) |
| self.int_fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, '', False, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.int_fd.max_value = 999 |
| self.config.field_defs = [self.int_fd] |
| self.services.config.StoreConfig('cnxn', self.config) |
| |
| def testApplyAllIssueChanges(self): |
| issue_delta_pairs = [] |
| no_change_iid = 78942 |
| |
| expected_issues_to_update = {} |
| expected_amendments = {} |
| expected_imp_amendments = {} |
| expected_old_owners = {} |
| expected_old_statuses = {} |
| expected_old_components = {} |
| expected_merged_from_add = {} |
| expected_new_starrers = {} |
| |
| issue_main = _Issue('proj', 100) |
| issue_main_ref = ('proj', issue_main.local_id) |
| issue_main.owner_id = 999 |
| issue_main.cc_ids = [111, 222] |
| issue_main.labels = ['dont_touch', 'remove_me'] |
| |
| expected_main = copy.deepcopy(issue_main) |
| expected_main.owner_id = 888 |
| expected_main.cc_ids = [111, 333] |
| expected_main.labels = ['dont_touch', 'add_me'] |
| expected_amendments[issue_main.issue_id] = [ |
| tracker_bizobj.MakeOwnerAmendment(888, 999), |
| tracker_bizobj.MakeCcAmendment([333], [222]), |
| tracker_bizobj.MakeLabelsAmendment(['add_me'], ['remove_me']) |
| ] |
| expected_old_owners[issue_main.issue_id] = 999 |
| |
| # blocked_on issues changes setup. |
| bo_add = _Issue('proj', 1) |
| self.services.issue.TestAddIssue(bo_add) |
| expected_bo_add = copy.deepcopy(bo_add) |
| # All impacted issues should be fetched within ApplyAllIssueChanges |
| # directly from the DB, skipping cache with `use_cache=False` in GetIssue(). |
| # So we expect these issues to have assume_stale=False. |
| expected_bo_add.assume_stale = False |
| expected_bo_add.blocking_iids = [issue_main.issue_id] |
| expected_issues_to_update[expected_bo_add.issue_id] = expected_bo_add |
| expected_imp_amendments[bo_add.issue_id] = [ |
| tracker_bizobj.MakeBlockingAmendment( |
| [issue_main_ref], [], default_project_name='proj') |
| ] |
| |
| bo_remove = _Issue('proj', 2) |
| bo_remove.blocking_iids = [issue_main.issue_id] |
| self.services.issue.TestAddIssue(bo_remove) |
| expected_bo_remove = copy.deepcopy(bo_remove) |
| expected_bo_remove.assume_stale = False |
| expected_bo_remove.blocking_iids = [] |
| expected_issues_to_update[expected_bo_remove.issue_id] = expected_bo_remove |
| expected_imp_amendments[bo_remove.issue_id] = [ |
| tracker_bizobj.MakeBlockingAmendment( |
| [], [issue_main_ref], default_project_name='proj') |
| ] |
| |
| issue_main.blocked_on_iids = [no_change_iid, bo_remove.issue_id] |
| # By default new blocked_on issues that appear in blocked_on_iids |
| # with no prior rank associated with it are un-ranked and assigned rank 0. |
| # See SortBlockedOn in issue_svc.py. |
| issue_main.blocked_on_ranks = [0, 0] |
| expected_main.blocked_on_iids = [no_change_iid, bo_add.issue_id] |
| expected_main.blocked_on_ranks = [0, 0] |
| expected_amendments[issue_main.issue_id].append( |
| tracker_bizobj.MakeBlockedOnAmendment( |
| [('proj', bo_add.local_id)], [('proj', bo_remove.local_id)], |
| default_project_name='proj')) |
| |
| # blocking_issues changes setup. |
| b_add = _Issue('proj', 3) |
| self.services.issue.TestAddIssue(b_add) |
| expected_b_add = copy.deepcopy(b_add) |
| expected_b_add.assume_stale = False |
| expected_b_add.blocked_on_iids = [issue_main.issue_id] |
| expected_b_add.blocked_on_ranks = [0] |
| expected_issues_to_update[expected_b_add.issue_id] = expected_b_add |
| expected_imp_amendments[b_add.issue_id] = [ |
| tracker_bizobj.MakeBlockedOnAmendment( |
| [issue_main_ref], [], default_project_name='proj') |
| ] |
| |
| b_remove = _Issue('proj', 4) |
| b_remove.blocked_on_iids = [issue_main.issue_id] |
| self.services.issue.TestAddIssue(b_remove) |
| expected_b_remove = copy.deepcopy(b_remove) |
| expected_b_remove.assume_stale = False |
| expected_b_remove.blocked_on_iids = [] |
| # Test we can process delta changes and impact changes. |
| delta_b_remove = tracker_pb2.IssueDelta(labels_add=['more_chickens']) |
| expected_b_remove.labels = ['more_chickens'] |
| issue_delta_pairs.append((b_remove, delta_b_remove)) |
| expected_issues_to_update[expected_b_remove.issue_id] = expected_b_remove |
| expected_imp_amendments[b_remove.issue_id] = [ |
| tracker_bizobj.MakeBlockedOnAmendment( |
| [], [issue_main_ref], default_project_name='proj') |
| ] |
| expected_amendments[b_remove.issue_id] = [ |
| tracker_bizobj.MakeLabelsAmendment(['more_chickens'], []) |
| ] |
| |
| issue_main.blocking_iids = [no_change_iid, b_remove.issue_id] |
| expected_main.blocking_iids = [no_change_iid, b_add.issue_id] |
| expected_amendments[issue_main.issue_id].append( |
| tracker_bizobj.MakeBlockingAmendment( |
| [('proj', b_add.local_id)], [('proj', b_remove.local_id)], |
| default_project_name='proj')) |
| |
| # Merged issues changes setup. |
| merge_remove = _Issue('proj', 5) |
| self.services.issue.TestAddIssue(merge_remove) |
| expected_merge_remove = copy.deepcopy(merge_remove) |
| expected_merge_remove.assume_stale = False |
| expected_issues_to_update[ |
| expected_merge_remove.issue_id] = expected_merge_remove |
| expected_imp_amendments[merge_remove.issue_id] = [ |
| tracker_bizobj.MakeMergedIntoAmendment( |
| [], [issue_main_ref], default_project_name='proj') |
| ] |
| |
| merge_add = _Issue('proj', 6) |
| self.services.issue.TestAddIssue(merge_add) |
| expected_merge_add = copy.deepcopy(merge_add) |
| expected_merge_add.assume_stale = False |
| # We are adding 333 and removing 222 in issue_main with delta_main. |
| expected_merge_add.cc_ids = [expected_main.owner_id, 333, 111] |
| expected_merged_from_add[expected_merge_add.issue_id] = [ |
| issue_main.issue_id |
| ] |
| |
| expected_imp_amendments[merge_add.issue_id] = [ |
| tracker_bizobj.MakeCcAmendment(expected_merge_add.cc_ids, []), |
| tracker_bizobj.MakeMergedIntoAmendment( |
| [issue_main_ref], [], default_project_name='proj') |
| ] |
| # We are merging issue_main into merge_add, so issue_main's starrers |
| # should be merged into merge_add's starrers. |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, None, issue_main.issue_id, 111, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, None, issue_main.issue_id, 222, True) |
| expected_merge_add.star_count = 2 |
| expected_new_starrers[merge_add.issue_id] = [222, 111] |
| |
| expected_issues_to_update[expected_merge_add.issue_id] = expected_merge_add |
| |
| |
| issue_main.merged_into = merge_remove.issue_id |
| expected_main.merged_into = merge_add.issue_id |
| expected_amendments[issue_main.issue_id].append( |
| tracker_bizobj.MakeMergedIntoAmendment( |
| [('proj', merge_add.local_id)], [('proj', merge_remove.local_id)], |
| default_project_name='proj')) |
| |
| self.services.issue.TestAddIssue(issue_main) |
| expected_issues_to_update[expected_main.issue_id] = expected_main |
| |
| |
| # Issues we'll put in delta_main.*_remove fields that aren't in issue_main. |
| # These issues should not show up in issues_to_update. |
| missing_1 = _Issue('proj', 404) |
| expected_missing_1 = copy.deepcopy(missing_1) |
| expected_missing_1.assume_stale = False |
| self.services.issue.TestAddIssue(missing_1) |
| missing_2 = _Issue('proj', 405) |
| self.services.issue.TestAddIssue(missing_2) |
| expected_missing_2 = copy.deepcopy(missing_2) |
| expected_missing_2.assume_stale = False |
| |
| delta_main = tracker_pb2.IssueDelta( |
| owner_id=888, |
| cc_ids_remove=[222, 404], cc_ids_add=[333], |
| labels_remove=['remove_me', 'remove_404'], labels_add=['add_me'], |
| merged_into=merge_add.issue_id, |
| blocked_on_add=[bo_add.issue_id], |
| blocked_on_remove=[bo_remove.issue_id, missing_1.issue_id], |
| blocking_add=[b_add.issue_id], |
| blocking_remove=[b_remove.issue_id, missing_2.issue_id]) |
| issue_delta_pairs.append((issue_main, delta_main)) |
| |
| actual_tuple = tracker_helpers.ApplyAllIssueChanges( |
| self.cnxn, issue_delta_pairs, self.services) |
| |
| expected_tuple = tracker_helpers._IssueChangesTuple( |
| expected_issues_to_update, expected_merged_from_add, |
| expected_amendments, expected_imp_amendments, expected_old_owners, |
| expected_old_statuses, expected_old_components, expected_new_starrers) |
| self.assertEqual(actual_tuple, expected_tuple) |
| |
| self.assertEqual(missing_1, expected_missing_1) |
| self.assertEqual(missing_2, expected_missing_2) |
| |
| def testApplyAllIssueChanges_NOOP(self): |
| """Check we can ignore issue-delta pairs that are NOOP.""" |
| noop_issue = _Issue('proj', 1) |
| bo_add_noop = _Issue('proj', 2) |
| bo_remove_noop = _Issue('proj', 3) |
| |
| noop_issue.owner_id = 111 |
| noop_issue.cc_ids = [222] |
| noop_issue.blocked_on_iids = [bo_add_noop.issue_id] |
| bo_add_noop.blocking_iids = [noop_issue.issue_id] |
| |
| self.services.issue.TestAddIssue(noop_issue) |
| self.services.issue.TestAddIssue(bo_add_noop) |
| self.services.issue.TestAddIssue(bo_remove_noop) |
| expected_noop_issue = copy.deepcopy(noop_issue) |
| noop_delta = tracker_pb2.IssueDelta( |
| owner_id=noop_issue.owner_id, |
| cc_ids_add=noop_issue.cc_ids, cc_ids_remove=[333], |
| blocked_on_add=noop_issue.blocked_on_iids, |
| blocked_on_remove=[bo_remove_noop.issue_id]) |
| issue_delta_pairs = [(noop_issue, noop_delta)] |
| |
| actual_tuple = tracker_helpers.ApplyAllIssueChanges( |
| self.cnxn, issue_delta_pairs, self.services) |
| expected_tuple = tracker_helpers._IssueChangesTuple( |
| {}, {}, {}, {}, {}, {}, {}, {}) |
| self.assertEqual(actual_tuple, expected_tuple) |
| |
| self.assertEqual(noop_issue, expected_noop_issue) |
| |
| def testApplyAllIssueChanges_Empty(self): |
| issue_delta_pairs = [] |
| actual_tuple = tracker_helpers.ApplyAllIssueChanges( |
| self.cnxn, issue_delta_pairs, self.services) |
| expected_tuple = tracker_helpers._IssueChangesTuple( |
| {}, {}, {}, {}, {}, {}, {}, {}) |
| self.assertEqual(actual_tuple, expected_tuple) |
| |
| def testUpdateClosedTimestamp(self): |
| config = tracker_pb2.ProjectIssueConfig() |
| config.well_known_statuses.append( |
| tracker_pb2.StatusDef(status='New', means_open=True)) |
| config.well_known_statuses.append( |
| tracker_pb2.StatusDef(status='Accepted', means_open=True)) |
| config.well_known_statuses.append( |
| tracker_pb2.StatusDef(status='Old', means_open=False)) |
| config.well_known_statuses.append( |
| tracker_pb2.StatusDef(status='Closed', means_open=False)) |
| |
| issue = tracker_pb2.Issue() |
| issue.local_id = 1234 |
| issue.status = 'New' |
| |
| # ensure the default value is undef |
| self.assertTrue(not issue.closed_timestamp) |
| |
| # ensure transitioning to the same and other open states |
| # doesn't set the timestamp |
| issue.status = 'New' |
| tracker_helpers.UpdateClosedTimestamp(config, issue, 'New') |
| self.assertTrue(not issue.closed_timestamp) |
| |
| issue.status = 'Accepted' |
| tracker_helpers.UpdateClosedTimestamp(config, issue, 'New') |
| self.assertTrue(not issue.closed_timestamp) |
| |
| # ensure transitioning from open to closed sets the timestamp |
| issue.status = 'Closed' |
| tracker_helpers.UpdateClosedTimestamp(config, issue, 'Accepted') |
| self.assertTrue(issue.closed_timestamp) |
| |
| # ensure that the timestamp is cleared when transitioning from |
| # closed to open |
| issue.status = 'New' |
| tracker_helpers.UpdateClosedTimestamp(config, issue, 'Closed') |
| self.assertTrue(not issue.closed_timestamp) |
| |
| def testGroupUniqueDeltaIssues(self): |
| """We can identify unique IssueDeltas and group Issues by their deltas.""" |
| issue_1 = _Issue('proj', 1) |
| delta_1 = tracker_pb2.IssueDelta(cc_ids_add=[111]) |
| |
| issue_2 = _Issue('proj', 2) |
| delta_2 = tracker_pb2.IssueDelta(cc_ids_add=[111], cc_ids_remove=[222]) |
| |
| issue_3 = _Issue('proj', 3) |
| delta_3 = tracker_pb2.IssueDelta(cc_ids_add=[111]) |
| |
| issue_4 = _Issue('proj', 4) |
| delta_4 = tracker_pb2.IssueDelta() |
| |
| issue_5 = _Issue('proj', 5) |
| delta_5 = tracker_pb2.IssueDelta() |
| |
| issue_delta_pairs = [ |
| (issue_1, delta_1), (issue_2, delta_2), (issue_3, delta_3), |
| (issue_4, delta_4), (issue_5, delta_5) |
| ] |
| unique_deltas, issues_for_deltas = tracker_helpers.GroupUniqueDeltaIssues( |
| issue_delta_pairs) |
| |
| expected_unique_deltas = [delta_1, delta_2, delta_4] |
| self.assertEqual(unique_deltas, expected_unique_deltas) |
| expected_issues_for_deltas = [ |
| [issue_1, issue_3], [issue_2], [issue_4, issue_5] |
| ] |
| self.assertEqual(issues_for_deltas, expected_issues_for_deltas) |
| |
| def testEnforceAttachmentQuotaLimits(self): |
| self.services.project.TestAddProject('Circe', project_id=798) |
| issue_a1 = _Issue('Circe', 1, project_id=798) |
| delta_a1 = tracker_pb2.IssueDelta() |
| |
| issue_a2 = _Issue('Circe', 2, project_id=798) |
| delta_a2 = tracker_pb2.IssueDelta() |
| |
| self.services.project.TestAddProject('Patroclus', project_id=788) |
| issue_b1 = _Issue('Patroclus', 1, project_id=788) |
| delta_b1 = tracker_pb2.IssueDelta() |
| |
| issue_delta_pairs = [ |
| (issue_a1, delta_a1), (issue_a2, delta_a2), (issue_b1, delta_b1) |
| ] |
| |
| upload_1 = framework_helpers.AttachmentUpload( |
| 'dragon', 'OOOOOO\n', 'text/plain') |
| upload_2 = framework_helpers.AttachmentUpload( |
| 'snake', 'ooooo\n', 'text/plain') |
| attachment_uploads = [upload_1, upload_2] |
| |
| actual = tracker_helpers._EnforceAttachmentQuotaLimits( |
| self.cnxn, issue_delta_pairs, self.services, attachment_uploads) |
| |
| expected = { |
| 798: len(upload_1.contents + upload_2.contents) * 2, |
| 788: len(upload_1.contents + upload_2.contents) |
| } |
| self.assertEqual(actual, expected) |
| |
| @mock.patch('tracker.tracker_constants.ISSUE_ATTACHMENTS_QUOTA_HARD', 1) |
| def testEnforceAttachmentQuotaLimits_Exceeded(self): |
| self.services.project.TestAddProject('Circe', project_id=798) |
| issue_a1 = _Issue('Circe', 1, project_id=798) |
| delta_a1 = tracker_pb2.IssueDelta() |
| |
| issue_a2 = _Issue('Circe', 2, project_id=798) |
| delta_a2 = tracker_pb2.IssueDelta() |
| |
| self.services.project.TestAddProject('Patroclus', project_id=788) |
| issue_b1 = _Issue('Patroclus', 1, project_id=788) |
| delta_b1 = tracker_pb2.IssueDelta() |
| |
| issue_delta_pairs = [ |
| (issue_a1, delta_a1), (issue_a2, delta_a2), (issue_b1, delta_b1) |
| ] |
| |
| upload_1 = framework_helpers.AttachmentUpload( |
| 'dragon', 'OOOOOO\n', 'text/plain') |
| upload_2 = framework_helpers.AttachmentUpload( |
| 'snake', 'ooooo\n', 'text/plain') |
| attachment_uploads = [upload_1, upload_2] |
| |
| with self.assertRaisesRegexp(exceptions.OverAttachmentQuota, |
| r'.+ project Patroclus\n.+ project Circe'): |
| tracker_helpers._EnforceAttachmentQuotaLimits( |
| self.cnxn, issue_delta_pairs, self.services, attachment_uploads) |
| |
| def testAssertIssueChangesValid_Valid(self): |
| """We can assert when deltas are valid for issues.""" |
| impacted_issue = _Issue('chicken', 101) |
| self.services.issue.TestAddIssue(impacted_issue) |
| |
| issue_1 = _Issue('chicken', 1) |
| self.services.issue.TestAddIssue(issue_1) |
| delta_1 = tracker_pb2.IssueDelta( |
| merged_into=impacted_issue.issue_id, status='Duplicate') |
| exp_d1 = copy.deepcopy(delta_1) |
| |
| issue_2 = _Issue('chicken', 2) |
| self.services.issue.TestAddIssue(issue_2) |
| delta_2 = tracker_pb2.IssueDelta(blocked_on_add=[impacted_issue.issue_id]) |
| exp_d2 = copy.deepcopy(delta_2) |
| |
| issue_3 = _Issue('chicken', 3) |
| self.services.issue.TestAddIssue(issue_3) |
| delta_3 = tracker_pb2.IssueDelta() |
| exp_d3 = copy.deepcopy(delta_3) |
| |
| issue_4 = _Issue('chicken', 4) |
| self.services.issue.TestAddIssue(issue_4) |
| delta_4 = tracker_pb2.IssueDelta(owner_id=self.project_member.user_id) |
| exp_d4 = copy.deepcopy(delta_4) |
| |
| issue_5 = _Issue('chicken', 5) |
| self.services.issue.TestAddIssue(issue_5) |
| fv = tracker_bizobj.MakeFieldValue( |
| self.int_fd.field_id, 998, None, None, None, None, False) |
| delta_5 = tracker_pb2.IssueDelta(field_vals_add=[fv]) |
| exp_d5 = copy.deepcopy(delta_5) |
| |
| issue_6 = _Issue('chicken', 6) |
| self.services.issue.TestAddIssue(issue_6) |
| delta_6 = tracker_pb2.IssueDelta( |
| summary=' ' + 's' * tracker_constants.MAX_SUMMARY_CHARS + ' ') |
| exp_d6 = copy.deepcopy(delta_6) |
| |
| issue_7 = _Issue('chicken', 7) |
| self.services.issue.TestAddIssue(issue_7) |
| issue_8 = _Issue('chicken', 8) |
| self.services.issue.TestAddIssue(issue_8) |
| |
| # We are fine with duplicate/consistent deltas. |
| delta_7 = tracker_pb2.IssueDelta(blocked_on_add=[issue_8.issue_id]) |
| exp_d7 = copy.deepcopy(delta_7) |
| delta_8 = tracker_pb2.IssueDelta(blocking_add=[issue_7.issue_id]) |
| exp_d8 = copy.deepcopy(delta_8) |
| |
| issue_9 = _Issue('chicken', 9) |
| self.services.issue.TestAddIssue(issue_9) |
| issue_10 = _Issue('chicken', 10) |
| self.services.issue.TestAddIssue(issue_10) |
| |
| delta_9 = tracker_pb2.IssueDelta(blocked_on_remove=[issue_10.issue_id]) |
| exp_d9 = copy.deepcopy(delta_9) |
| delta_10 = tracker_pb2.IssueDelta(blocking_remove=[issue_9.issue_id]) |
| exp_d10 = copy.deepcopy(delta_10) |
| |
| issue_11 = _Issue('chicken', 11) |
| user_fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.USER_TYPE, None, '', False, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.services.config.TestAddFieldDef(user_fd) |
| a_user = self.services.user.TestAddUser('a_user@test.com', 123) |
| delta_11 = tracker_pb2.IssueDelta( |
| cc_ids_add=[222], |
| field_vals_add=[ |
| tracker_bizobj.MakeFieldValue( |
| user_fd.field_id, None, None, a_user.user_id, None, None, False) |
| ]) |
| exp_d11 = copy.deepcopy(delta_11) |
| |
| issue_delta_pairs = [ |
| (issue_1, delta_1), (issue_2, delta_2), (issue_3, delta_3), |
| (issue_4, delta_4), (issue_5, delta_5), (issue_6, delta_6), |
| (issue_7, delta_7), (issue_8, delta_8), (issue_9, delta_9), |
| (issue_10, delta_10), (issue_11, delta_11) |
| ] |
| comment = ' ' + 'c' * tracker_constants.MAX_COMMENT_CHARS + ' ' |
| tracker_helpers._AssertIssueChangesValid( |
| self.cnxn, issue_delta_pairs, self.services, comment_content=comment) |
| |
| # Check we can handle None `comment_content`. |
| tracker_helpers._AssertIssueChangesValid( |
| self.cnxn, issue_delta_pairs, self.services) |
| self.assertEqual( |
| [ |
| exp_d1, exp_d2, exp_d3, exp_d4, exp_d5, exp_d6, exp_d7, exp_d8, |
| exp_d9, exp_d10, exp_d11 |
| ], [ |
| delta_1, delta_2, delta_3, delta_4, delta_5, delta_6, delta_7, |
| delta_8, delta_9, delta_10, delta_11 |
| ]) |
| |
| def testAssertIssueChangesValid_RequiredField(self): |
| """Asserts fields and requried fields..""" |
| issue_1 = _Issue('chicken', 1) |
| self.services.issue.TestAddIssue(issue_1) |
| delta_1 = tracker_pb2.IssueDelta() |
| exp_d1 = copy.deepcopy(delta_1) |
| |
| required_fd = tracker_bizobj.MakeFieldDef( |
| 124, 789, 'StrField', tracker_pb2.FieldTypes.STR_TYPE, None, '', True, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.services.config.TestAddFieldDef(required_fd) |
| |
| issue_delta_pairs = [(issue_1, delta_1)] |
| comment = 'just a plain comment' |
| tracker_helpers._AssertIssueChangesValid( |
| self.cnxn, issue_delta_pairs, self.services, comment_content=comment) |
| |
| # Check we can handle adding a field value when issue is in invalid state. |
| fv = tracker_bizobj.MakeFieldValue( |
| self.int_fd.field_id, 998, None, None, None, None, False) |
| delta_2 = tracker_pb2.IssueDelta(field_vals_add=[fv]) |
| exp_d2 = copy.deepcopy(delta_2) |
| tracker_helpers._AssertIssueChangesValid( |
| self.cnxn, issue_delta_pairs, self.services) |
| self.assertEqual([exp_d1, exp_d2], [delta_1, delta_2]) |
| |
| def testAssertIssueChangesValid_Invalid(self): |
| """We can raise exceptions when deltas are not valid for issues. """ |
| |
| def getRef(issue): |
| return '%s:%d' % (issue.project_name, issue.local_id) |
| |
| issue_delta_pairs = [] |
| expected_err_msgs = [] |
| |
| comment = 'c' * (tracker_constants.MAX_COMMENT_CHARS + 1) |
| expected_err_msgs.append('Comment is too long.') |
| |
| issue_1 = _Issue('chicken', 1) |
| self.services.issue.TestAddIssue(issue_1) |
| issue_1_ref = getRef(issue_1) |
| |
| delta_1 = tracker_pb2.IssueDelta( |
| merged_into=issue_1.issue_id, |
| blocked_on_add=[issue_1.issue_id], |
| summary='', |
| status='', |
| cc_ids_add=[9876]) |
| |
| issue_delta_pairs.append((issue_1, delta_1)) |
| expected_err_msgs.extend( |
| [ |
| ('%s: MERGED type statuses must accompany mergedInto values.') % |
| issue_1_ref, |
| '%s: Cannot merge an issue into itself.' % issue_1_ref, |
| '%s: Cannot block an issue on itself.' % issue_1_ref, |
| 'users/9876: User does not exist.', |
| '%s: Summary required.' % issue_1_ref, |
| '%s: Status is required.' % issue_1_ref |
| ]) |
| |
| issue_2 = _Issue('chicken', 2) |
| self.services.issue.TestAddIssue(issue_2) |
| issue_2_ref = getRef(issue_2) |
| |
| fv = tracker_bizobj.MakeFieldValue( |
| self.int_fd.field_id, 1000, None, None, None, None, False) |
| delta_2 = tracker_pb2.IssueDelta( |
| status='Duplicate', |
| blocking_add=[issue_2.issue_id], |
| summary='s' * (tracker_constants.MAX_SUMMARY_CHARS + 1), |
| owner_id=self.no_project_user.user_id, |
| field_vals_add=[fv]) |
| issue_delta_pairs.append((issue_2, delta_2)) |
| |
| expected_err_msgs.extend( |
| [ |
| ('%s: MERGED type statuses must accompany mergedInto values.') % |
| issue_2_ref, |
| '%s: Cannot block an issue on itself.' % issue_2_ref, |
| '%s: Issue owner must be a project member.' % issue_2_ref, |
| '%s: Summary is too long.' % issue_2_ref, |
| '%s: Error for %r: Value must be <= 999.' % (issue_2_ref, fv) |
| ]) |
| |
| issue_3 = _Issue('chicken', 3) |
| issue_3.status = 'Duplicate' |
| issue_3.merged_into = 78911 |
| self.services.issue.TestAddIssue(issue_3) |
| issue_3_ref = getRef(issue_3) |
| delta_3 = tracker_pb2.IssueDelta( |
| status='Available', merged_into_external='b/123') |
| issue_delta_pairs.append((issue_3, delta_3)) |
| expected_err_msgs.append( |
| '%s: MERGED type statuses must accompany mergedInto values.' % |
| issue_3_ref) |
| |
| with self.assertRaisesRegexp(exceptions.InputException, |
| '\n'.join(expected_err_msgs)): |
| tracker_helpers._AssertIssueChangesValid( |
| self.cnxn, issue_delta_pairs, self.services, comment_content=comment) |
| |
| def testAssertIssueChangesValid_ConflictingDeltas(self): |
| |
| def getRef(issue): |
| return '%s:%d' % (issue.project_name, issue.local_id) |
| |
| expected_err_msgs = [] |
| issue_3 = _Issue('chicken', 3) |
| self.services.issue.TestAddIssue(issue_3) |
| issue_3_ref = getRef(issue_3) |
| issue_4 = _Issue('chicken', 4) |
| self.services.issue.TestAddIssue(issue_4) |
| issue_4_ref = getRef(issue_4) |
| issue_5 = _Issue('chicken', 5) |
| self.services.issue.TestAddIssue(issue_5) |
| issue_5_ref = getRef(issue_5) |
| issue_6 = _Issue('chicken', 6) |
| self.services.issue.TestAddIssue(issue_6) |
| issue_6_ref = getRef(issue_6) |
| issue_7 = _Issue('chicken', 7) |
| self.services.issue.TestAddIssue(issue_7) |
| issue_7_ref = getRef(issue_7) |
| |
| delta_3 = tracker_pb2.IssueDelta( |
| blocking_add=[issue_4.issue_id], |
| blocked_on_add=[issue_5.issue_id, issue_6.issue_id]) |
| |
| delta_4 = tracker_pb2.IssueDelta( |
| blocked_on_remove=[issue_3.issue_id], blocking_add=[issue_5.issue_id]) |
| expected_err_msgs.append( |
| 'Changes for %s conflict for %s' % (issue_4_ref, issue_3_ref)) |
| |
| delta_5 = tracker_pb2.IssueDelta( |
| blocking_remove=[issue_3.issue_id], |
| blocked_on_remove=[issue_4.issue_id]) |
| expected_err_msgs.append( |
| 'Changes for %s conflict for %s, %s' % |
| (issue_5_ref, issue_3_ref, issue_4_ref)) |
| |
| delta_6 = tracker_pb2.IssueDelta(blocking_remove=[issue_3.issue_id]) |
| expected_err_msgs.append( |
| 'Changes for %s conflict for %s' % (issue_6_ref, issue_3_ref)) |
| |
| impacted_issue = _Issue('chicken', 11) |
| self.services.issue.TestAddIssue(impacted_issue) |
| impacted_issue_ref = getRef(impacted_issue) |
| delta_7 = tracker_pb2.IssueDelta( |
| blocking_remove=[issue_3.issue_id], |
| blocking_add=[issue_3.issue_id], |
| blocked_on_remove=[impacted_issue.issue_id], |
| blocked_on_add=[impacted_issue.issue_id]) |
| expected_err_msgs.append( |
| 'Changes for %s conflict for %s, %s' % |
| (issue_7_ref, issue_3_ref, impacted_issue_ref)) |
| |
| issue_delta_pairs = [ |
| (issue_3, delta_3), |
| (issue_4, delta_4), |
| (issue_5, delta_5), |
| (issue_6, delta_6), |
| (issue_7, delta_7), |
| ] |
| |
| with self.assertRaisesRegexp(exceptions.InputException, |
| '\n'.join(expected_err_msgs)): |
| tracker_helpers._AssertIssueChangesValid( |
| self.cnxn, issue_delta_pairs, self.services) |
| |
| def testComputeNewCcsFromIssueMerge(self): |
| """We can compute the new ccs to add to a merge-into issue.""" |
| target_issue = fake.MakeTestIssue(789, 10, 'Target issue', 'New', 111) |
| source_issue_1 = fake.MakeTestIssue( |
| 789, 11, 'Source issue', 'New', 111) # different restrictions |
| source_issue_2 = fake.MakeTestIssue( |
| 789, 12, 'Source issue', 'New', 222) # same restrictions |
| source_issue_3 = fake.MakeTestIssue( |
| 789, 13, 'Source issue', 'New', 222) # no restrictions |
| source_issue_4 = fake.MakeTestIssue( |
| 789, 14, 'Source issue', 'New', 666) # empty ccs |
| source_issue_5 = fake.MakeTestIssue( |
| 788, 15, 'Source issue', 'New', 666) # different project |
| source_issue_1.cc_ids.append(333) |
| source_issue_2.cc_ids.append(444) |
| source_issue_3.cc_ids.append(555) |
| source_issue_5.cc_ids.append(999) |
| |
| target_issue.labels.append('Restrict-View-Chicken') |
| source_issue_1.labels.append('Restrict-View-Cow') |
| source_issue_2.labels.append('Restrict-View-Chicken') |
| |
| self.services.issue.TestAddIssue(target_issue) |
| self.services.issue.TestAddIssue(source_issue_1) |
| self.services.issue.TestAddIssue(source_issue_2) |
| self.services.issue.TestAddIssue(source_issue_3) |
| self.services.issue.TestAddIssue(source_issue_4) |
| self.services.issue.TestAddIssue(source_issue_5) |
| |
| new_cc_ids = tracker_helpers._ComputeNewCcsFromIssueMerge( |
| target_issue, [source_issue_1, source_issue_2, source_issue_3]) |
| self.assertItemsEqual(new_cc_ids, [444, 555, 222]) |
| |
| def testComputeNewCcsFromIssueMerge_Empty(self): |
| target_issue = fake.MakeTestIssue(789, 10, 'Target issue', 'New', 111) |
| self.services.issue.TestAddIssue(target_issue) |
| new_cc_ids = tracker_helpers._ComputeNewCcsFromIssueMerge(target_issue, []) |
| self.assertItemsEqual(new_cc_ids, []) |
| |
| def testEnforceNonMergeStatusDeltas(self): |
| # No updates: user is setting to a non-MERGED status with no |
| # existing merged_into values. |
| issue_1 = _Issue('chicken', 1) |
| self.services.issue.TestAddIssue(issue_1) |
| delta_1 = tracker_pb2.IssueDelta(status='Available') |
| exp_delta_1 = copy.deepcopy(delta_1) |
| |
| # No updates: user is setting to a MERGED status. Whether this request |
| # goes through will be handled by _AssertIssueChangesValid(). |
| issue_2 = _Issue('chicken', 2) |
| self.services.issue.TestAddIssue(issue_2) |
| delta_2 = tracker_pb2.IssueDelta(status='Duplicate') |
| exp_delta_2 = copy.deepcopy(delta_2) |
| |
| # No updates: user is setting to a MERGED status. (This test issue starts |
| # out with a merged_into value but a non-MERGED status. We don't expect |
| # real data to ever be in this state) |
| issue_3 = _Issue('chicken', 3) |
| issue_3.merged_into = 7011 |
| self.services.issue.TestAddIssue(issue_3) |
| delta_3 = tracker_pb2.IssueDelta(status='Duplicate') |
| exp_delta_3 = copy.deepcopy(delta_3) |
| |
| # No updates: same situation as above. |
| issue_4 = _Issue('chicken', 4) |
| issue_4.merged_into_external = 'b/123' |
| self.services.issue.TestAddIssue(issue_4) |
| delta_4 = tracker_pb2.IssueDelta(status='Duplicate') |
| exp_delta_4 = copy.deepcopy(delta_4) |
| |
| # Update delta: user is setting status AWAY from a MERGED status, so we |
| # auto-remove any existing merged_into values. |
| issue_5 = _Issue('chicken', 5) |
| issue_5.merged_into = 7011 |
| self.services.issue.TestAddIssue(issue_5) |
| delta_5 = tracker_pb2.IssueDelta(status='Available') |
| exp_delta_5 = copy.deepcopy(delta_5) |
| exp_delta_5.merged_into = 0 |
| |
| # Update delta: user is setting status AWAY from a MERGED status, so we |
| # auto-remove any existing merged_into values. |
| issue_6 = _Issue('chicken', 6) |
| issue_6.merged_into_external = 'b/123' |
| self.services.issue.TestAddIssue(issue_6) |
| delta_6 = tracker_pb2.IssueDelta(status='Available') |
| exp_delta_6 = copy.deepcopy(delta_6) |
| exp_delta_6.merged_into_external = '' |
| |
| # No updates: user is setting to a non-MERGED status while also setting |
| # a merged_into value. This will be rejected down the line by |
| # _AssertIssueChangesValid() |
| issue_7 = _Issue('chicken', 7) |
| issue_7.merged_into = 7011 |
| self.services.issue.TestAddIssue(issue_7) |
| delta_7 = tracker_pb2.IssueDelta( |
| merged_into_external='b/123', status='Available') |
| exp_delta_7 = copy.deepcopy(delta_7) |
| |
| # No updates: user is setting to a non-MERGED status while also setting |
| # a merged_into value. This will be rejected down the line by |
| # _AssertIssueChangesValid() |
| issue_8 = _Issue('chicken', 8) |
| issue_8.merged_into_external = 'b/123' |
| self.services.issue.TestAddIssue(issue_8) |
| delta_8 = tracker_pb2.IssueDelta(merged_into=8011, status='Available') |
| exp_delta_8 = copy.deepcopy(delta_8) |
| |
| pairs = [ |
| (issue_1, delta_1), (issue_2, delta_2), (issue_3, delta_3), |
| (issue_4, delta_4), (issue_5, delta_5), (issue_6, delta_6), |
| (issue_7, delta_7), (issue_8, delta_8) |
| ] |
| |
| tracker_helpers._EnforceNonMergeStatusDeltas( |
| self.cnxn, pairs, self.services) |
| self.assertEqual( |
| [ |
| delta_1, delta_2, delta_3, delta_4, delta_5, delta_6, delta_7, |
| delta_8 |
| ], [ |
| exp_delta_1, exp_delta_2, exp_delta_3, exp_delta_4, exp_delta_5, |
| exp_delta_6, exp_delta_7, exp_delta_8 |
| ]) |
| |
| |
| class IssueChangeImpactedIssuesTest(unittest.TestCase): |
| """Tests for the _IssueChangeImpactedIssues class.""" |
| |
| def setUp(self): |
| self.services = service_manager.Services( |
| issue=fake.IssueService(), issue_star=fake.IssueStarService()) |
| self.cnxn = 'fake connection' |
| |
| def testComputeAllImpactedIDs(self): |
| tracker = tracker_helpers._IssueChangeImpactedIssues() |
| tracker.blocking_add[78901].append(1) |
| tracker.blocking_remove[78902].append(2) |
| tracker.blocked_on_add[78903].append(1) |
| tracker.blocked_on_remove[78904].append(1) |
| tracker.merged_from_add[78905].append(3) |
| tracker.merged_from_remove[78906].append(3) |
| |
| # Repeat a few iids. |
| tracker.blocked_on_remove[78901].append(1) |
| tracker.merged_from_add[78903].append(1) |
| |
| actual = tracker.ComputeAllImpactedIIDs() |
| expected = {78901, 78902, 78903, 78904, 78905, 78906} |
| self.assertEqual(actual, expected) |
| |
| def testComputeAllImpactedIDs_Empty(self): |
| tracker = tracker_helpers._IssueChangeImpactedIssues() |
| actual = tracker.ComputeAllImpactedIIDs() |
| self.assertEqual(actual, set()) |
| |
| def testTrackImpactedIssues(self): |
| issue_delta_pairs = [] |
| |
| issue_1 = _Issue('project', 1) |
| issue_1.merged_into = 78906 |
| delta_1 = tracker_pb2.IssueDelta( |
| merged_into=78905, |
| blocked_on_add=[78901, 78902], |
| blocked_on_remove=[78903, 78904], |
| ) |
| issue_delta_pairs.append((issue_1, delta_1)) |
| |
| issue_2 = _Issue('project', 2) |
| issue_2.merged_into = 78905 |
| delta_2 = tracker_pb2.IssueDelta( |
| merged_into=78905, # This should be ignored. |
| blocking_add=[78901, 78902], |
| blocking_remove=[78903, 78904], |
| ) |
| issue_delta_pairs.append((issue_2, delta_2)) |
| |
| issue_3 = _Issue('project', 3) |
| issue_3.merged_into = 78902 |
| delta_3 = tracker_pb2.IssueDelta(merged_into=78901) |
| issue_delta_pairs.append((issue_3, delta_3)) |
| |
| issue_4 = _Issue('project', 4) |
| issue_4.merged_into = 78901 |
| delta_4 = tracker_pb2.IssueDelta( |
| merged_into=framework_constants.NO_ISSUE_SPECIFIED) |
| issue_delta_pairs.append((issue_4, delta_4)) |
| |
| impacted_issues = tracker_helpers._IssueChangeImpactedIssues() |
| for issue, delta in issue_delta_pairs: |
| impacted_issues.TrackImpactedIssues(issue, delta) |
| |
| self.assertEqual( |
| impacted_issues.blocking_add, { |
| 78901: [issue_1.issue_id], |
| 78902: [issue_1.issue_id] |
| }) |
| self.assertEqual( |
| impacted_issues.blocking_remove, { |
| 78903: [issue_1.issue_id], |
| 78904: [issue_1.issue_id] |
| }) |
| self.assertEqual( |
| impacted_issues.blocked_on_add, { |
| 78901: [issue_2.issue_id], |
| 78902: [issue_2.issue_id] |
| }) |
| self.assertEqual( |
| impacted_issues.blocked_on_remove, { |
| 78903: [issue_2.issue_id], |
| 78904: [issue_2.issue_id] |
| }) |
| self.assertEqual( |
| impacted_issues.merged_from_add, { |
| 78901: [issue_3.issue_id], |
| 78905: [issue_1.issue_id], |
| }) |
| self.assertEqual( |
| impacted_issues.merged_from_remove, { |
| 78901: [issue_4.issue_id], |
| 78902: [issue_3.issue_id], |
| 78906: [issue_1.issue_id], |
| }) |
| |
| def testApplyImpactedIssueChanges(self): |
| impacted_tracker = tracker_helpers._IssueChangeImpactedIssues() |
| impacted_issue = _Issue('proj', 1) |
| self.services.issue.TestAddIssue(impacted_issue) |
| impacted_iid = impacted_issue.issue_id |
| |
| # Setup. |
| bo_add = _Issue('proj', 2) |
| self.services.issue.TestAddIssue(bo_add) |
| impacted_tracker.blocked_on_add[impacted_iid].append(bo_add.issue_id) |
| |
| bo_remove = _Issue('proj', 3) |
| self.services.issue.TestAddIssue(bo_remove) |
| impacted_tracker.blocked_on_remove[impacted_iid].append( |
| bo_remove.issue_id) |
| |
| b_add = _Issue('proj', 4) |
| self.services.issue.TestAddIssue(b_add) |
| impacted_tracker.blocking_add[impacted_iid].append( |
| b_add.issue_id) |
| |
| b_remove = _Issue('proj', 5) |
| self.services.issue.TestAddIssue(b_remove) |
| impacted_tracker.blocking_remove[impacted_iid].append( |
| b_remove.issue_id) |
| |
| m_add = _Issue('proj', 6) |
| m_add.cc_ids = [666, 777] |
| self.services.issue.TestAddIssue(m_add) |
| m_add_no_ccs = _Issue('proj', 7, '', '') |
| self.services.issue.TestAddIssue(m_add_no_ccs) |
| impacted_tracker.merged_from_add[impacted_iid].extend( |
| [m_add.issue_id, m_add_no_ccs.issue_id]) |
| # Set up starrers. |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, None, impacted_iid, 111, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, None, impacted_iid, 222, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, None, m_add.issue_id, 222, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, None, m_add.issue_id, 333, True) |
| self.services.issue_star.SetStar( |
| self.cnxn, self.services, None, m_add.issue_id, 444, True) |
| |
| m_remove = _Issue('proj', 8) |
| m_remove.cc_ids = [888] |
| self.services.issue.TestAddIssue(m_remove) |
| impacted_tracker.merged_from_remove[impacted_iid].append( |
| m_remove.issue_id) |
| |
| |
| impacted_issue.cc_ids = [666] |
| impacted_issue.blocked_on_iids = [78404, bo_remove.issue_id] |
| impacted_issue.blocking_iids = [78405, b_remove.issue_id] |
| expected_issue = copy.deepcopy(impacted_issue) |
| |
| # Verify. |
| (actual_amendments, |
| actual_new_starrers) = impacted_tracker.ApplyImpactedIssueChanges( |
| self.cnxn, impacted_issue, self.services) |
| expected_amendments = [ |
| tracker_bizobj.MakeBlockedOnAmendment( |
| [('proj', bo_add.local_id)], |
| [('proj', bo_remove.local_id)], default_project_name='proj'), |
| tracker_bizobj.MakeBlockingAmendment( |
| [('proj', b_add.local_id)], |
| [('proj', b_remove.local_id)], default_project_name='proj'), |
| tracker_bizobj.MakeCcAmendment([777], []), |
| tracker_bizobj.MakeMergedIntoAmendment( |
| [('proj', m_add.local_id), ('proj', m_add_no_ccs.local_id)], |
| [('proj', m_remove.local_id)], default_project_name='proj') |
| ] |
| self.assertEqual(actual_amendments, expected_amendments) |
| self.assertItemsEqual(actual_new_starrers, [333, 444]) |
| |
| expected_issue.cc_ids.append(777) |
| expected_issue.blocked_on_iids = [78404, bo_add.issue_id] |
| # By default new blocked_on issues that appear in blocked_on_iids |
| # with no prior rank associated with it are un-ranked and assigned rank 0. |
| # See SortBlockedOn in issue_svc.py. |
| expected_issue.blocked_on_ranks = [0, 0] |
| expected_issue.blocking_iids = [78405, b_add.issue_id] |
| expected_issue.star_count = 4 |
| self.assertEqual(impacted_issue, expected_issue) |
| |
| def testApplyImpactedIssueChanges_Empty(self): |
| impacted_tracker = tracker_helpers._IssueChangeImpactedIssues() |
| impacted_issue = _Issue('proj', 1) |
| expected_issue = copy.deepcopy(impacted_issue) |
| |
| (actual_amendments, |
| actual_new_starrers) = impacted_tracker.ApplyImpactedIssueChanges( |
| self.cnxn, impacted_issue, self.services) |
| |
| expected_amendments = [] |
| self.assertEqual(actual_amendments, expected_amendments) |
| expected_new_starrers = [] |
| self.assertEqual(actual_new_starrers, expected_new_starrers) |
| self.assertEqual(impacted_issue, expected_issue) |
| |
| def testApplyImpactedIssueChanges_PartiallyEmptyMergedFrom(self): |
| """We can process merged_from changes when one of the lists is empty.""" |
| impacted_tracker = tracker_helpers._IssueChangeImpactedIssues() |
| impacted_issue = _Issue('proj', 1) |
| impacted_iid = impacted_issue.issue_id |
| expected_issue = copy.deepcopy(impacted_issue) |
| |
| m_add = _Issue('proj', 2) |
| self.services.issue.TestAddIssue(m_add) |
| impacted_tracker.merged_from_add[impacted_iid].append( |
| m_add.issue_id) |
| # We're leaving impacted_tracker.merged_from_remove empty. |
| |
| (actual_amendments, |
| actual_new_starrers) = impacted_tracker.ApplyImpactedIssueChanges( |
| self.cnxn, impacted_issue, self.services) |
| |
| expected_amendments = [tracker_bizobj.MakeMergedIntoAmendment( |
| [('proj', m_add.local_id)], [], default_project_name='proj')] |
| self.assertEqual(actual_amendments, expected_amendments) |
| expected_new_starrers = [] |
| self.assertEqual(actual_new_starrers, expected_new_starrers) |
| self.assertEqual(impacted_issue, expected_issue) |
| |
| |
| class AssertUsersExistTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.cnxn = 'fake cnxn' |
| self.services = service_manager.Services(user=fake.UserService()) |
| for user_id in [1, 1001, 1002, 1003, 2001, 2002, 3002]: |
| self.services.user.TestAddUser('test%d' % user_id, user_id, add_user=True) |
| |
| def test_AssertUsersExist_Passes(self): |
| existing = [1, 1001, 1002, 1003, 2001, 2002, 3002] |
| with exceptions.ErrorAggregator(exceptions.InputException) as err_agg: |
| tracker_helpers.AssertUsersExist( |
| self.cnxn, self.services, existing, err_agg) |
| |
| def test_AssertUsersExist_Empty(self): |
| with exceptions.ErrorAggregator(exceptions.InputException) as err_agg: |
| tracker_helpers.AssertUsersExist( |
| self.cnxn, self.services, [], err_agg) |
| |
| def test_AssertUsersExist(self): |
| dne_users = [2, 3] |
| existing = [1, 1001, 1002, 1003, 2001, 2002, 3002] |
| all_users = existing + dne_users |
| with self.assertRaisesRegexp( |
| exceptions.InputException, |
| 'users/2: User does not exist.\nusers/3: User does not exist.'): |
| with exceptions.ErrorAggregator(exceptions.InputException) as err_agg: |
| tracker_helpers.AssertUsersExist( |
| self.cnxn, self.services, all_users, err_agg) |