Project import generated by Copybara.
GitOrigin-RevId: d9e9e3fb4e31372ec1fb43b178994ca78fa8fe70
diff --git a/businesslogic/test/work_env_test.py b/businesslogic/test/work_env_test.py
new file mode 100644
index 0000000..63ac60f
--- /dev/null
+++ b/businesslogic/test/work_env_test.py
@@ -0,0 +1,7381 @@
+# Copyright 2017 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Tests for the WorkEnv class."""
+from __future__ import print_function
+from __future__ import division
+from __future__ import absolute_import
+
+import copy
+import logging
+import sys
+import unittest
+import mock
+
+from google.appengine.api import memcache
+from google.appengine.ext import testbed
+
+import settings
+from businesslogic import work_env
+from features import filterrules_helpers
+from framework import authdata
+from framework import exceptions
+from framework import framework_constants
+from framework import framework_helpers
+from framework import framework_views
+from framework import permissions
+from framework import sorting
+from features import send_notifications
+from proto import features_pb2
+from proto import project_pb2
+from proto import tracker_pb2
+from proto import user_pb2
+from services import config_svc
+from services import features_svc
+from services import issue_svc
+from services import project_svc
+from services import user_svc
+from services import usergroup_svc
+from services import service_manager
+from services import spam_svc
+from services import star_svc
+from services import template_svc
+from testing import fake
+from testing import testing_helpers
+from tracker import tracker_bizobj
+from tracker import tracker_constants
+
+
+def _Issue(project_id, local_id):
+ # TODO(crbug.com/monorail/8124): Many parts of monorail's codebase
+ # assumes issue.owner_id could never be None and that issues without
+ # owners have owner_id = 0.
+ issue = tracker_pb2.Issue(owner_id=0)
+ issue.project_name = 'proj-%d' % project_id
+ issue.project_id = project_id
+ issue.local_id = local_id
+ issue.issue_id = project_id*100 + local_id
+ return issue
+
+
+class WorkEnvTest(unittest.TestCase):
+
+ def setUp(self):
+ self.cnxn = 'fake connection'
+ self.services = service_manager.Services(
+ config=fake.ConfigService(),
+ cache_manager=fake.CacheManager(),
+ issue=fake.IssueService(),
+ user=fake.UserService(),
+ project=fake.ProjectService(),
+ issue_star=fake.IssueStarService(),
+ project_star=fake.ProjectStarService(),
+ user_star=fake.UserStarService(),
+ hotlist_star=fake.HotlistStarService(),
+ features=fake.FeaturesService(),
+ usergroup=fake.UserGroupService(),
+ template=mock.Mock(spec=template_svc.TemplateService),
+ spam=fake.SpamService())
+ self.project = self.services.project.TestAddProject(
+ 'proj', project_id=789, committer_ids=[111])
+ self.component_id_1 = self.services.config.CreateComponentDef(
+ self.cnxn, self.project.project_id, 'Component', 'Docstring', False, [],
+ [], 0, 111, [])
+ self.component_id_2 = self.services.config.CreateComponentDef(
+ self.cnxn, self.project.project_id, 'Component>Test', 'Docstring',
+ False, [], [], 0, 111, [])
+
+ config = fake.MakeTestConfig(self.project.project_id, [], [])
+ config.well_known_statuses = [
+ tracker_pb2.StatusDef(status='Fixed', means_open=False)
+ ]
+ self.services.config.StoreConfig(self.cnxn, config)
+ self.admin_user = self.services.user.TestAddUser(
+ 'admin@example.com', 444)
+ self.admin_user.is_site_admin = True
+ self.user_1 = self.services.user.TestAddUser('user_111@example.com', 111)
+ self.user_2 = self.services.user.TestAddUser('user_222@example.com', 222)
+ self.user_3 = self.services.user.TestAddUser('user_333@example.com', 333)
+ self.hotlist = self.services.features.TestAddHotlist(
+ 'myhotlist', summary='old sum', owner_ids=[self.user_1.user_id],
+ editor_ids=[self.user_2.user_id], description='old desc',
+ is_private=True)
+ # reserved for testing that a hotlist does not exist
+ self.dne_hotlist_id = 1234
+ self.mr = testing_helpers.MakeMonorailRequest(project=self.project)
+ self.mr.perms = permissions.READ_ONLY_PERMISSIONSET
+ self.field_def_1_name = 'test_field_1'
+ self.field_def_1 = fake.MakeTestFieldDef(
+ 101, self.project.project_id, tracker_pb2.FieldTypes.INT_TYPE,
+ field_name=self.field_def_1_name, max_value=10)
+ self.services.config.TestAddFieldDef(self.field_def_1)
+ self.PAST_TIME = 12345
+ self.dne_project_id = 999
+ sorting.InitializeArtValues(self.services)
+
+ self.work_env = work_env.WorkEnv(
+ self.mr, self.services, 'Testing phase')
+
+ def SignIn(self, user_id=111):
+ self.mr.auth = authdata.AuthData.FromUserID(
+ self.cnxn, user_id, self.services)
+ self.mr.perms = permissions.GetPermissions(
+ self.mr.auth.user_pb, self.mr.auth.effective_ids, self.project)
+
+ def testAssertUserCanModifyIssues_Empty(self):
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues([], True)
+
+ def testAssertUserCanModifyIssues_RestrictedFields(self):
+ restricted_int_fd = fake.MakeTestFieldDef(
+ 1, 789, tracker_pb2.FieldTypes.INT_TYPE,
+ field_name='int_field', is_restricted_field=True)
+ self.services.config.TestAddFieldDef(restricted_int_fd)
+
+ restricted_enum_fd = fake.MakeTestFieldDef(
+ 2, 789, tracker_pb2.FieldTypes.ENUM_TYPE,
+ field_name='enum_field',
+ is_restricted_field=True)
+ self.services.config.TestAddFieldDef(restricted_enum_fd)
+
+ issue = fake.MakeTestIssue(
+ 789, 1, 'summary', 'Available', self.admin_user.user_id)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(
+ summary='changing summary',
+ fields_clear=[restricted_int_fd.field_id],
+ labels_remove=['enum_field-test'])
+ issue_delta_pairs = [(issue, delta)]
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaisesRegexp(permissions.PermissionException,
+ r'.+int_field\n.+enum_field'):
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues(issue_delta_pairs, True)
+
+ # Add user_1 as an editor
+ restricted_int_fd.editor_ids = [self.user_1.user_id]
+ restricted_enum_fd.editor_ids = [self.user_1.user_id]
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues(issue_delta_pairs, True)
+
+ def testAssertUserCanModifyIssues_HasEditPerms(self):
+ issue = fake.MakeTestIssue(
+ 789, 1, 'summary', 'Available', self.admin_user.user_id)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(summary='changing summary', cc_ids_add=[111])
+ issue_delta_pairs = [(issue, delta)]
+
+ # Committer can edit issues.
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues(
+ issue_delta_pairs, True, comment_content='ping')
+
+ def testAssertUserCanModifyIssues_MergedInto(self):
+ issue = fake.MakeTestIssue(
+ 789, 1, 'summary', 'Available', self.admin_user.user_id)
+ self.services.issue.TestAddIssue(issue)
+
+ restricted_issue = fake.MakeTestIssue(
+ 789, 2, 'summary', 'Aavailable', self.admin_user.user_id,
+ labels=['Restrict-View-Chicken'])
+ self.services.issue.TestAddIssue(restricted_issue)
+
+ issue_delta_pairs = [
+ (issue, tracker_pb2.IssueDelta(merged_into=restricted_issue.issue_id))
+ ]
+
+ # Committer cannot merge into issue they cannot edit.
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues(
+ issue_delta_pairs, True, comment_content='ping')
+
+ def testAssertUserCanModifyIssues_HasFineGrainedPerms(self):
+ self.services.project.TestAddProject(
+ 'projWithExtraPerms',
+ project_id=788,
+ contrib_ids=[self.user_1.user_id],
+ extra_perms=[
+ project_pb2.Project.ExtraPerms(
+ member_id=self.user_1.user_id,
+ perms=[
+ permissions.ADD_ISSUE_COMMENT,
+ permissions.EDIT_ISSUE_SUMMARY, permissions.EDIT_ISSUE_OWNER
+ ])
+ ])
+ error_messages_re = []
+
+ # user_1 can update issue summaries in the project.
+ issue_1 = fake.MakeTestIssue(
+ 788, 1, 'summary', 'Available', self.admin_user.user_id,
+ project_name='farm')
+ self.services.issue.TestAddIssue(issue_1)
+ issue_delta_pairs = [(issue_1, tracker_pb2.IssueDelta(summary='bok bok'))]
+
+ # user_1 does not have EDIT_ISSUE_CC perms in project.
+ error_messages_re.append(r'.+changes to issue farm:2')
+ issue_2 = fake.MakeTestIssue(
+ 788, 2, 'summary', 'Fixed', self.admin_user.user_id,
+ project_name='farm')
+ self.services.issue.TestAddIssue(issue_2)
+ issue_delta_pairs.append(
+ (issue_2, tracker_pb2.IssueDelta(cc_ids_add=[777])))
+
+ # user_1 does not have EDIT_ISSUE_STATUS perms in project.
+ error_messages_re.append(r'.+changes to issue farm:3')
+ issue_3 = fake.MakeTestIssue(
+ 788, 3, 'summary', 'Fixed', self.admin_user.user_id,
+ project_name='farm')
+ self.services.issue.TestAddIssue(issue_3)
+ issue_delta_pairs.append(
+ (issue_3, tracker_pb2.IssueDelta(status='eggsHatching')))
+
+ # user_1 can update issue owners in the project.
+ issue_4 = fake.MakeTestIssue(
+ 788, 4, 'summary', 'Fixed', self.admin_user.user_id,
+ project_name='farm')
+ self.services.issue.TestAddIssue(issue_3)
+ issue_delta_pairs.append(
+ (issue_4, tracker_pb2.IssueDelta(owner_id=self.user_2.user_id)))
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaisesRegexp(permissions.PermissionException,
+ '\n'.join(error_messages_re)):
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues(
+ issue_delta_pairs, False, comment_content='ping')
+
+ def testAssertUserCanModifyIssues_IssueGrantedPerms(self):
+ """We properly take issue granted permissions into account."""
+ granting_fd = tracker_pb2.FieldDef(
+ field_name='grants_editissue',
+ field_id=1,
+ field_type=tracker_pb2.FieldTypes.USER_TYPE,
+ grants_perm='editissue')
+ config = fake.MakeTestConfig(789, [], [])
+ config.field_defs = [granting_fd]
+ self.services.config.StoreConfig('cnxn', config)
+
+ # we add user_2 to "grants_editissue" field which should grant them
+ # "EditIssue" in this issue.
+ issue = fake.MakeTestIssue(
+ 789, 1, 'summary', 'Available', self.admin_user.user_id,
+ field_values=[
+ tracker_pb2.FieldValue(field_id=1, user_id=self.user_2.user_id)
+ ])
+ self.services.issue.TestAddIssue(issue)
+ issue_delta_pairs = [
+ (issue, tracker_pb2.IssueDelta(summary='changing summary'))
+ ]
+
+ self.SignIn(user_id=self.user_2.user_id)
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues(issue_delta_pairs, False)
+
+ self.SignIn(user_id=self.user_3.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we._AssertUserCanModifyIssues(issue_delta_pairs, False)
+
+
+ # FUTURE: GetSiteReadOnlyState()
+ # FUTURE: SetSiteReadOnlyState()
+ # FUTURE: GetSiteBannerMessage()
+ # FUTURE: SetSiteBannerMessage()
+
+ def testCreateProject_Normal(self):
+ """We can create a project."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ project_id = we.CreateProject(
+ 'newproj', [111], [222], [333], 'summary', 'desc')
+ actual = we.GetProject(project_id)
+
+ self.assertEqual('summary', actual.summary)
+ self.assertEqual('desc', actual.description)
+ self.services.template.CreateDefaultProjectTemplates\
+ .assert_called_once_with(self.mr.cnxn, project_id)
+
+ def testCreateProject_AlreadyExists(self):
+ """We can create a project."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ # Project 'proj' is created in setUp().
+ with self.assertRaises(exceptions.ProjectAlreadyExists):
+ with self.work_env as we:
+ we.CreateProject('proj', [111], [222], [333], 'summary', 'desc')
+
+ self.assertFalse(
+ self.services.template.CreateDefaultProjectTemplates.called)
+
+ def testCreateProject_NotAllowed(self):
+ """A user without permissions cannon create a project."""
+ self.SignIn()
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CreateProject('proj', [111], [222], [333], 'summary', 'desc')
+
+ self.assertFalse(
+ self.services.template.CreateDefaultProjectTemplates.called)
+
+ def testCheckProjectName_OK(self):
+ """We can check a project name."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ self.assertIsNone(we.CheckProjectName('foo'))
+
+ def testCheckProjectName_InvalidProjectName(self):
+ """We can check an invalid project name."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckProjectName('Foo'))
+
+ def testCheckProjectName_AlreadyExists(self):
+ """There is already a project with that name."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckProjectName('proj'))
+
+ def testCheckProjectName_NotAllowed(self):
+ """Users that can't create a project shouldn't get any information."""
+ self.SignIn()
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CheckProjectName('Foo')
+
+ def testCheckComponentName_OK(self):
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNone(we.CheckComponentName(
+ self.project.project_id, None, 'Component'))
+
+ def testCheckComponentName_ParentComponentOK(self):
+ self.services.config.CreateComponentDef(
+ self.cnxn, self.project.project_id, 'Component', 'Docstring',
+ False, [], [], 0, 111, [])
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNone(we.CheckComponentName(
+ self.project.project_id, 'Component', 'SubComponent'))
+
+ def testCheckComponentName_InvalidComponentName(self):
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckComponentName(
+ self.project.project_id, None, 'Component>Foo'))
+
+ def testCheckComponentName_ComponentAlreadyExists(self):
+ self.services.config.CreateComponentDef(
+ self.cnxn, self.project.project_id, 'Component', 'Docstring',
+ False, [], [], 0, 111, [])
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckComponentName(
+ self.project.project_id, None, 'Component'))
+
+ def testCheckComponentName_NotAllowedToViewProject(self):
+ self.project.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ self.SignIn(333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CheckComponentName(self.project.project_id, None, 'Component')
+
+ def testCheckComponentName_ParentComponentDoesntExist(self):
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchComponentException):
+ with self.work_env as we:
+ we.CheckComponentName(
+ self.project.project_id, 'Component', 'SubComponent')
+
+ def testCheckFieldName_OK(self):
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNone(we.CheckFieldName(
+ self.project.project_id, 'Field'))
+
+ def testCheckFieldName_InvalidFieldName(self):
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckFieldName(
+ self.project.project_id, '**Field**'))
+
+ def testCheckFieldName_FieldAlreadyExists(self):
+ fd = fake.MakeTestFieldDef(
+ 1, self.project.project_id, tracker_pb2.FieldTypes.STR_TYPE,
+ field_name='Field')
+ self.services.config.TestAddFieldDef(fd)
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckFieldName(
+ self.project.project_id, 'Field'))
+
+ def testCheckFieldName_FieldIsPrefixOfAnother(self):
+ fd = fake.MakeTestFieldDef(
+ 1, self.project.project_id, tracker_pb2.FieldTypes.STR_TYPE,
+ field_name='Field-Foo')
+ self.services.config.TestAddFieldDef(fd)
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckFieldName(
+ self.project.project_id, 'Field'))
+
+ def testCheckFieldName_AnotherFieldIsPrefix(self):
+ fd = fake.MakeTestFieldDef(
+ 1, self.project.project_id, tracker_pb2.FieldTypes.STR_TYPE,
+ field_name='Field')
+ self.services.config.TestAddFieldDef(fd)
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckFieldName(
+ self.project.project_id, 'Field-Foo'))
+
+ def testCheckFieldName_ReservedPrefix(self):
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckFieldName(
+ self.project.project_id, 'Summary'))
+
+ def testCheckFieldName_ReservedSuffix(self):
+ self.SignIn()
+ with self.work_env as we:
+ self.assertIsNotNone(we.CheckFieldName(
+ self.project.project_id, 'Chicken-ApproveR'))
+
+ def testCheckFieldName_NotAllowedToViewProject(self):
+ self.project.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ self.SignIn(user_id=333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CheckFieldName(self.project.project_id, 'Field')
+
+ def testListProjects(self):
+ """We can get the project IDs of projects visible to the current user."""
+ # Project 789 is created in setUp()
+ self.services.project.TestAddProject(
+ 'proj2', project_id=2, access=project_pb2.ProjectAccess.MEMBERS_ONLY)
+ self.services.project.TestAddProject('proj3', project_id=3)
+ with self.work_env as we:
+ actual = we.ListProjects()
+
+ self.assertEqual([3, 789], actual)
+
+ @mock.patch('settings.branded_domains',
+ {'proj3': 'branded.com', '*': 'bugs.chromium.org'})
+ def testListProjects_BrandedDomain_NotLive(self):
+ """Branded domains don't affect localhost and demo servers."""
+ # Project 789 is created in setUp()
+ self.services.project.TestAddProject(
+ 'proj2', project_id=2, access=project_pb2.ProjectAccess.MEMBERS_ONLY)
+ self.services.project.TestAddProject('proj3', project_id=3)
+
+ with self.work_env as we:
+ actual = we.ListProjects(domain='localhost:8080')
+ self.assertEqual([3, 789], actual)
+
+ actual = we.ListProjects(domain='app-id.appspot.com')
+ self.assertEqual([3, 789], actual)
+
+ @mock.patch('settings.branded_domains',
+ {'proj3': 'branded.com', '*': 'bugs.chromium.org'})
+ def testListProjects_BrandedDomain_LiveSite(self):
+ """Project list only contains projects on the current branded domain."""
+ # Project 789 is created in setUp()
+ self.services.project.TestAddProject(
+ 'proj2', project_id=2, access=project_pb2.ProjectAccess.MEMBERS_ONLY)
+ self.services.project.TestAddProject('proj3', project_id=3)
+
+ with self.work_env as we:
+ actual = we.ListProjects(domain='branded.com')
+ self.assertEqual([3], actual)
+
+ actual = we.ListProjects(domain='bugs.chromium.org')
+ self.assertEqual([789], actual)
+
+ def testGetProject_Normal(self):
+ """We can get an existing project by project_id."""
+ with self.work_env as we:
+ actual = we.GetProject(789)
+
+ self.assertEqual(self.project, actual)
+
+ def testGetProject_NoSuchProject(self):
+ """We reject attempts to get a non-existent project."""
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ _actual = we.GetProject(999)
+
+ def testGetProject_NotAllowed(self):
+ """We reject attempts to get a project we don't have permission to."""
+ self.project.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ _actual = we.GetProject(789)
+
+ def testGetProjectByName_Normal(self):
+ """We can get an existing project by project_name."""
+ with self.work_env as we:
+ actual = we.GetProjectByName('proj')
+
+ self.assertEqual(self.project, actual)
+
+ def testGetProjectByName_NoSuchProject(self):
+ """We reject attempts to get a non-existent project."""
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ _actual = we.GetProjectByName('huh-what')
+
+ def testGetProjectByName_NoPermission(self):
+ """We reject attempts to get a project we don't have permissions to."""
+ self.project.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ _actual = we.GetProjectByName('proj')
+
+ def AddUserProjects(self):
+ project_states = {
+ 'live': project_pb2.ProjectState.LIVE,
+ 'archived': project_pb2.ProjectState.ARCHIVED,
+ 'deletable': project_pb2.ProjectState.DELETABLE}
+
+ projects = {}
+ for name, state in project_states.items():
+ projects['owner-'+name] = self.services.project.TestAddProject(
+ 'owner-' + name, state=state, owner_ids=[222])
+ projects['committer-'+name] = self.services.project.TestAddProject(
+ 'committer-' + name, state=state, committer_ids=[222])
+ projects['contributor-'+name] = self.services.project.TestAddProject(
+ 'contributor-' + name, state=state)
+ projects['contributor-'+name].contributor_ids = [222]
+
+ projects['members-only'] = self.services.project.TestAddProject(
+ 'members-only', owner_ids=[222])
+ projects['members-only'].access = (
+ project_pb2.ProjectAccess.MEMBERS_ONLY)
+
+ return projects
+
+ def testGatherProjectMembershipsForUser_OtherUser(self):
+ """We can get the projects in which a user has a role.
+ Member only projects are hidden."""
+ projects = self.AddUserProjects()
+
+ with self.work_env as we:
+ owner, committer, contrib = we.GatherProjectMembershipsForUser(222)
+
+ self.assertEqual([projects['owner-live'].project_id], owner)
+ self.assertEqual([projects['committer-live'].project_id], committer)
+ self.assertEqual([projects['contributor-live'].project_id], contrib)
+
+ def testGatherProjectMembershipsForUser_OwnUser(self):
+ """We can get the projects in which the logged in user has a role. """
+ projects = self.AddUserProjects()
+
+ self.SignIn(user_id=222)
+ with self.work_env as we:
+ owner, committer, contrib = we.GatherProjectMembershipsForUser(222)
+
+ self.assertEqual(
+ [
+ projects['members-only'].project_id,
+ projects['owner-live'].project_id
+ ], owner)
+ self.assertEqual([projects['committer-live'].project_id], committer)
+ self.assertEqual([projects['contributor-live'].project_id], contrib)
+
+ def testGatherProjectMembershipsForUser_Admin(self):
+ """Admins can see all project roles another user has. """
+ projects = self.AddUserProjects()
+
+ self.SignIn(user_id=444)
+ with self.work_env as we:
+ owner, committer, contrib = we.GatherProjectMembershipsForUser(222)
+
+ self.assertEqual(
+ [
+ projects['members-only'].project_id,
+ projects['owner-live'].project_id
+ ], owner)
+ self.assertEqual([projects['committer-live'].project_id], committer)
+ self.assertEqual([projects['contributor-live'].project_id], contrib)
+
+ def testGetUserRolesInAllProjects_OtherUsers(self):
+ """We can get the projects in which the user has a role."""
+ projects = self.AddUserProjects()
+
+ with self.work_env as we:
+ owner, member, contrib = we.GetUserRolesInAllProjects({222})
+
+ by_name = lambda project: project.project_name
+ self.assertEqual(
+ [projects['owner-live']],
+ sorted(list(owner.values()), key=by_name))
+ self.assertEqual(
+ [projects['committer-live']],
+ sorted(list(member.values()), key=by_name))
+ self.assertEqual(
+ [projects['contributor-live']],
+ sorted(list(contrib.values()), key=by_name))
+
+ def testGetUserRolesInAllProjects_OwnUser(self):
+ """We can get the projects in which the user has a role."""
+ projects = self.AddUserProjects()
+
+ self.SignIn(user_id=222)
+ with self.work_env as we:
+ owner, member, contrib = we.GetUserRolesInAllProjects({222})
+
+ by_name = lambda project: project.project_name
+ self.assertEqual(
+ [projects['members-only'], projects['owner-archived'],
+ projects['owner-live']],
+ sorted(list(owner.values()), key=by_name))
+ self.assertEqual(
+ [projects['committer-archived'], projects['committer-live']],
+ sorted(list(member.values()), key=by_name))
+ self.assertEqual(
+ [projects['contributor-archived'], projects['contributor-live']],
+ sorted(list(contrib.values()), key=by_name))
+
+ def testGetUserRolesInAllProjects_Admin(self):
+ """We can get the projects in which the user has a role."""
+ projects = self.AddUserProjects()
+
+ self.SignIn(user_id=444)
+ with self.work_env as we:
+ owner, member, contrib = we.GetUserRolesInAllProjects({222})
+
+ by_name = lambda project: project.project_name
+ self.assertEqual(
+ [projects['members-only'], projects['owner-archived'],
+ projects['owner-deletable'], projects['owner-live']],
+ sorted(list(owner.values()), key=by_name))
+ self.assertEqual(
+ [projects['committer-archived'], projects['committer-deletable'],
+ projects['committer-live']],
+ sorted(list(member.values()), key=by_name))
+ self.assertEqual(
+ [projects['contributor-archived'], projects['contributor-deletable'],
+ projects['contributor-live']],
+ sorted(list(contrib.values()), key=by_name))
+
+ def testGetUserProjects_OnlyLiveOfOtherUsers(self):
+ """Regular users should only see live projects of other users."""
+ projects = self.AddUserProjects()
+
+ self.SignIn()
+ with self.work_env as we:
+ owner, archived, member, contrib = we.GetUserProjects({222})
+
+ self.assertEqual([projects['owner-live']], owner)
+ self.assertEqual([], archived)
+ self.assertEqual([projects['committer-live']], member)
+ self.assertEqual([projects['contributor-live']], contrib)
+
+ def testGetUserProjects_AdminSeesAll(self):
+ """Admins should see all projects from other users."""
+ projects = self.AddUserProjects()
+
+ self.SignIn(user_id=444)
+ with self.work_env as we:
+ owner, archived, member, contrib = we.GetUserProjects({222})
+
+ self.assertEqual([projects['members-only'], projects['owner-live']], owner)
+ self.assertEqual([projects['owner-archived']], archived)
+ self.assertEqual([projects['committer-live']], member)
+ self.assertEqual([projects['contributor-live']], contrib)
+
+ def testGetUserProjects_UserSeesOwnProjects(self):
+ """Users should see all own projects."""
+ projects = self.AddUserProjects()
+
+ self.SignIn(user_id=222)
+ with self.work_env as we:
+ owner, archived, member, contrib = we.GetUserProjects({222})
+
+ self.assertEqual([projects['members-only'], projects['owner-live']], owner)
+ self.assertEqual([projects['owner-archived']], archived)
+ self.assertEqual([projects['committer-live']], member)
+ self.assertEqual([projects['contributor-live']], contrib)
+
+ def testUpdateProject_Normal(self):
+ """We can update an existing project."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ we.UpdateProject(789, read_only_reason='test reason')
+ project = we.GetProject(789)
+
+ self.assertEqual('test reason', project.read_only_reason)
+
+ def testUpdateProject_NoSuchProject(self):
+ """Updating a nonexistent project raises an exception."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.UpdateProject(999, summary='new summary')
+
+ def testDeleteProject_Normal(self):
+ """We can mark an existing project as deletable."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ we.DeleteProject(789)
+
+ self.assertEqual(project_pb2.ProjectState.DELETABLE, self.project.state)
+
+ def testDeleteProject_NoSuchProject(self):
+ """Changing a nonexistent project raises an exception."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.DeleteProject(999)
+
+ def testStarProject_Normal(self):
+ """We can star and unstar a project."""
+ self.SignIn()
+ with self.work_env as we:
+ self.assertFalse(we.IsProjectStarred(789))
+ we.StarProject(789, True)
+ self.assertTrue(we.IsProjectStarred(789))
+ we.StarProject(789, False)
+ self.assertFalse(we.IsProjectStarred(789))
+
+ def testStarProject_NoSuchProject(self):
+ """We can't star a nonexistent project."""
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.StarProject(999, True)
+
+ def testStarProject_Anon(self):
+ """Anon user can't star a project."""
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.StarProject(789, True)
+
+ def testIsProjectStarred_Normal(self):
+ """We can check if a project is starred."""
+ # Tested by method testStarProject_Normal().
+ pass
+
+ def testIsProjectStarred_NoProjectSpecified(self):
+ """A project ID must be specified."""
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ self.assertFalse(we.IsProjectStarred(None))
+
+ def testIsProjectStarred_NoSuchProject(self):
+ """We can't check for stars on a nonexistent project."""
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.IsProjectStarred(999)
+
+ def testGetProjectStarCount_Normal(self):
+ """We can count the stars of a project."""
+ self.SignIn()
+ with self.work_env as we:
+ self.assertEqual(0, we.GetProjectStarCount(789))
+ we.StarProject(789, True)
+ self.assertEqual(1, we.GetProjectStarCount(789))
+
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ we.StarProject(789, True)
+ self.assertEqual(2, we.GetProjectStarCount(789))
+ we.StarProject(789, False)
+ self.assertEqual(1, we.GetProjectStarCount(789))
+
+ def testGetProjectStarCount_NoSuchProject(self):
+ """We can't count stars of a nonexistent project."""
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.GetProjectStarCount(999)
+
+ def testGetProjectStarCount_NoProjectSpecified(self):
+ """A project ID must be specified."""
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ self.assertFalse(we.GetProjectStarCount(None))
+
+ def testListStarredProjects_ViewingSelf(self):
+ """A user can view their own starred projects, if they still have access."""
+ project1 = self.services.project.TestAddProject('proj1', project_id=1)
+ project2 = self.services.project.TestAddProject('proj2', project_id=2)
+ with self.work_env as we:
+ self.SignIn()
+ we.StarProject(project1.project_id, True)
+ we.StarProject(project2.project_id, True)
+ self.assertItemsEqual(
+ [project1, project2], we.ListStarredProjects())
+ project2.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ self.assertItemsEqual(
+ [project1], we.ListStarredProjects())
+
+ def testListStarredProjects_ViewingOther(self):
+ """A user can view their own starred projects, if they still have access."""
+ project1 = self.services.project.TestAddProject('proj1', project_id=1)
+ project2 = self.services.project.TestAddProject('proj2', project_id=2)
+ with self.work_env as we:
+ self.SignIn(user_id=222)
+ we.StarProject(project1.project_id, True)
+ we.StarProject(project2.project_id, True)
+ self.SignIn(user_id=111)
+ self.assertEqual([], we.ListStarredProjects())
+ self.assertItemsEqual(
+ [project1, project2], we.ListStarredProjects(viewed_user_id=222))
+ project2.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ self.assertItemsEqual(
+ [project1], we.ListStarredProjects(viewed_user_id=222))
+
+ def testGetProjectConfig_Normal(self):
+ """We can get an existing config by project_id."""
+ config = fake.MakeTestConfig(789, ['LabelOne'], ['New'])
+ self.services.config.StoreConfig('cnxn', config)
+ with self.work_env as we:
+ actual = we.GetProjectConfig(789)
+
+ self.assertEqual(config, actual)
+
+ def testGetProjectConfig_NoSuchProject(self):
+ """We reject attempts to get a non-existent config."""
+ self.services.config.strict = True
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ _actual = we.GetProjectConfig(self.dne_project_id)
+
+ def testListProjectTemplates_IsMember(self):
+ private_tmpl = tracker_pb2.TemplateDef(name='Chicken', members_only=True)
+ public_tmpl = tracker_pb2.TemplateDef(name='Kale', members_only=False)
+ self.services.template.GetProjectTemplates.return_value = [
+ private_tmpl, public_tmpl]
+
+ self.SignIn() # user 111 is a member of self.project
+
+ with self.work_env as we:
+ actual = we.ListProjectTemplates(self.project.project_id)
+
+ self.assertEqual(actual, [private_tmpl, public_tmpl])
+ self.services.template.GetProjectTemplates.assert_called_once_with(
+ self.mr.cnxn, self.project.project_id)
+
+ def testListProjectTemplates_IsNotMember(self):
+ private_tmpl = tracker_pb2.TemplateDef(name='Chicken', members_only=True)
+ public_tmpl = tracker_pb2.TemplateDef(name='Kale', members_only=False)
+ self.services.template.GetProjectTemplates.return_value = [
+ private_tmpl, public_tmpl]
+
+ with self.work_env as we:
+ actual = we.ListProjectTemplates(self.project.project_id)
+
+ self.assertEqual(actual, [public_tmpl])
+ self.services.template.GetProjectTemplates.assert_called_once_with(
+ self.mr.cnxn, self.project.project_id)
+
+ def testListComponentDefs(self):
+ project = self.services.project.TestAddProject(
+ 'Greece', owner_ids=[self.user_1.user_id])
+ config = fake.MakeTestConfig(project.project_id, [], [])
+ cd_1 = fake.MakeTestComponentDef(project.project_id, 1, path='Circe')
+ cd_2 = fake.MakeTestComponentDef(project.project_id, 2, path='Achilles')
+ cd_3 = fake.MakeTestComponentDef(project.project_id, 3, path='Patroclus')
+ config.component_defs = [cd_1, cd_2, cd_3]
+ self.services.config.StoreConfig(self.cnxn, config)
+
+ self.SignIn(self.user_1.user_id)
+ with self.work_env as we:
+ actual = we.ListComponentDefs(project.project_id, 10, 1)
+ self.assertEqual(actual, work_env.ListResult([cd_2, cd_3], None))
+
+ def testListComponentDefs_NotFound(self):
+ self.SignIn(self.user_2.user_id)
+
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.ListComponentDefs(404, 10, 1)
+
+ project = self.services.project.TestAddProject(
+ 'Greece',
+ owner_ids=[self.user_1.user_id],
+ access=project_pb2.ProjectAccess.MEMBERS_ONLY)
+ config = fake.MakeTestConfig(project.project_id, [], [])
+ cd_1 = fake.MakeTestComponentDef(project.project_id, 1, path='Circe')
+ config.component_defs = [cd_1]
+ self.services.config.StoreConfig(self.cnxn, config)
+
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.ListComponentDefs(project.project_id, 10, 1)
+
+ def testListComponentDefs_InvalidPaginate(self):
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.ListComponentDefs(404, -1, 10)
+
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.ListComponentDefs(404, 1, -10)
+
+ @mock.patch('time.time')
+ def testCreateComponentDef(self, fake_time):
+ now = 123
+ fake_time.return_value = now
+ project = self.services.project.TestAddProject(
+ 'Music', owner_ids=[self.user_1.user_id])
+ admin = self.services.user.TestAddUser('admin@test.com', 555)
+ self.SignIn(self.user_1.user_id)
+ with self.work_env as we:
+ actual = we.CreateComponentDef(
+ project.project_id, 'hanggai', 'hamtlag', [admin.user_id],
+ [self.user_2.user_id], ['taro', 'mowgli'])
+ self.assertEqual(actual.project_id, project.project_id)
+ self.assertEqual(actual.path, 'hanggai')
+ self.assertEqual(actual.docstring, 'hamtlag')
+ self.assertEqual(actual.admin_ids, [admin.user_id])
+ self.assertEqual(actual.cc_ids, [222])
+ self.assertFalse(actual.deprecated)
+ self.assertEqual(actual.created, now)
+ self.assertEqual(actual.creator_id, self.user_1.user_id)
+ self.assertEqual(
+ actual.label_ids,
+ self.services.config.LookupLabelIDs(
+ self.cnxn, project.project_id, ['taro', 'mowgli']))
+
+ # Test with ancestor.
+ self.SignIn(admin.user_id)
+ with self.work_env as we:
+ actual = we.CreateComponentDef(
+ project.project_id, 'hanggai>band', 'rock band',
+ [self.user_2.user_id], [], [])
+ self.assertEqual(actual.project_id, project.project_id)
+ self.assertEqual(actual.path, 'hanggai>band')
+ self.assertEqual(actual.docstring, 'rock band')
+ self.assertEqual(actual.admin_ids, [self.user_2.user_id])
+ self.assertFalse(actual.deprecated)
+ self.assertEqual(actual.created, now)
+ self.assertEqual(actual.creator_id, admin.user_id)
+
+ def testCreateComponentDef_InvalidUsers(self):
+ project = self.services.project.TestAddProject(
+ 'Music', owner_ids=[self.user_1.user_id])
+ self.SignIn(self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'hanggai', 'hamtlag', [404], [404], [])
+
+ def testCreateComponentDef_InvalidLeaf(self):
+ project = self.services.project.TestAddProject(
+ 'Music', owner_ids=[self.user_1.user_id])
+ self.SignIn(self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'music>hanggai.rockband', 'hamtlag', [], [], [])
+
+ def testCreateComponentDef_LeafAlreadyExists(self):
+ project = self.services.project.TestAddProject(
+ 'Music', owner_ids=[self.user_1.user_id])
+ self.SignIn(self.user_1.user_id)
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli', 'favorite things',
+ [self.user_1.user_id], [], [])
+ with self.assertRaises(exceptions.ComponentDefAlreadyExists):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli', 'more favorite things', [], [], [])
+
+ # Test components with ancestors are also checked correctly
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli>food', 'lots of chicken', [], [], [])
+ with self.assertRaises(exceptions.ComponentDefAlreadyExists):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli>food', 'lots of salmon', [], [], [])
+
+ def testCreateComponentDef_AncestorNotFound(self):
+ project = self.services.project.TestAddProject(
+ 'Music', owner_ids=[self.user_1.user_id])
+ self.SignIn(self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli>chicken', 'more favorite things', [],
+ [], [])
+
+ def testCreateComponentDef_PermissionDenied(self):
+ project = self.services.project.TestAddProject(
+ 'Music', owner_ids=[self.user_1.user_id])
+ admin = self.services.user.TestAddUser('admin@test.com', 888)
+ self.SignIn(self.user_1.user_id)
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli', 'favorite things', [admin.user_id], [],
+ [])
+ we.CreateComponentDef(
+ project.project_id, 'mowgli>beef', 'favorite things', [], [], [])
+
+ user = self.services.user.TestAddUser('user@test.com', 777)
+ self.SignIn(user.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'bambi', 'spring time', [], [], [])
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli>chicken', 'more favorite things', [],
+ [], [])
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CreateComponentDef(
+ project.project_id, 'mowgli>beef>rice', 'more favorite things', [],
+ [], [])
+
+ def testDeleteComponentDef(self):
+ project = self.services.project.TestAddProject(
+ 'Achilles', owner_ids=[self.user_1.user_id])
+ config = fake.MakeTestConfig(project.project_id, [], [])
+ component_def = fake.MakeTestComponentDef(
+ project.project_id, 1, path='Chickens>Dickens')
+ config.component_defs = [component_def]
+ self.services.config.StoreConfig(self.cnxn, config)
+
+ self.SignIn(self.user_1.user_id)
+ with self.work_env as we:
+ we.DeleteComponentDef(project.project_id, component_def.component_id)
+
+ self.assertEqual(config.component_defs, [])
+
+ def testDeleteComponentDef_NotFound(self):
+ project = self.services.project.TestAddProject(
+ 'Achilles', owner_ids=[self.user_1.user_id])
+
+ self.SignIn(self.user_1.user_id)
+ with self.assertRaises(exceptions.NoSuchComponentException):
+ with self.work_env as we:
+ we.DeleteComponentDef(project.project_id, 404)
+
+ def testDeleteComponentDef_CannotViewProject(self):
+ project = self.services.project.TestAddProject(
+ 'Achilles',
+ owner_ids=[self.user_1.user_id],
+ access=project_pb2.ProjectAccess.MEMBERS_ONLY)
+
+ self.SignIn(self.user_2.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.DeleteComponentDef(project.project_id, 404)
+
+ def testDeleteComponentDef_SubcomponentFound(self):
+ project = self.services.project.TestAddProject(
+ 'Achilles', owner_ids=[self.user_1.user_id])
+ config = fake.MakeTestConfig(project.project_id, [], [])
+ dickens_comp = fake.MakeTestComponentDef(
+ project.project_id, 1, path='Chickens>Dickens')
+ chickens_comp = fake.MakeTestComponentDef(
+ project.project_id, 2, path='Chickens')
+ config.component_defs = [chickens_comp, dickens_comp]
+ self.services.config.StoreConfig(self.cnxn, config)
+
+ self.SignIn(self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.DeleteComponentDef(project.project_id, chickens_comp.component_id)
+
+ def testDeleteComponentDef_NonComponentAdminsCannotDelete(self):
+ admin = self.services.user.TestAddUser('circe@test.com', 888)
+ user = self.services.user.TestAddUser('patroclus@test.com', 999)
+
+ project = self.services.project.TestAddProject(
+ 'Achilles', owner_ids=[self.user_1.user_id])
+ config = fake.MakeTestConfig(project.project_id, [], [])
+
+ dickens_comp = fake.MakeTestComponentDef(
+ project.project_id,
+ 1,
+ path='Chickens>Dickens',
+ )
+ dickens_comp.admin_ids = [admin.user_id]
+ chickens_comp = fake.MakeTestComponentDef(
+ project.project_id, 2, path='Chickens')
+
+ config.component_defs = [chickens_comp, dickens_comp]
+ self.services.config.StoreConfig(self.cnxn, config)
+
+ self.SignIn(admin.user_id)
+ with self.work_env as we:
+ we.DeleteComponentDef(project.project_id, dickens_comp.component_id)
+
+ self.SignIn(user.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.DeleteComponentDef(project.project_id, chickens_comp.component_id)
+
+
+ # FUTURE: labels, statuses, components, rules, templates, and views.
+ # FUTURE: project saved queries.
+ # FUTURE: GetProjectPermissionsForUser()
+
+ ### Field methods
+
+ # FUTURE: All other field methods.
+
+ def testGetFieldDef_Normal(self):
+ """We can get an existing fielddef by field_id."""
+ fd = fake.MakeTestFieldDef(
+ 2, self.project.project_id, tracker_pb2.FieldTypes.STR_TYPE,
+ field_name='Field')
+ self.services.config.TestAddFieldDef(fd)
+ config = self.services.config.GetProjectConfig(self.cnxn, 789)
+
+ with self.work_env as we:
+ actual = we.GetFieldDef(fd.field_id, self.project)
+
+ self.assertEqual(config.field_defs[1], actual)
+
+ def testGetFieldDef_NoSuchFieldDef(self):
+ """We reject attempts to get a non-existent field."""
+ with self.assertRaises(exceptions.NoSuchFieldDefException):
+ with self.work_env as we:
+ _actual = we.GetFieldDef(999, self.project)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_Normal(self, fake_pasicn, fake_pasibn):
+ """We can create an issue."""
+ self.SignIn(user_id=111)
+ approval_values = [tracker_pb2.ApprovalValue(approval_id=23, phase_id=3)]
+ phases = [tracker_pb2.Phase(name='Canary', phase_id=3)]
+ with self.work_env as we:
+ actual_issue, comment = we.CreateIssue(
+ 789,
+ 'sum',
+ 'New',
+ 111, [333], ['Hot'], [], [],
+ 'desc',
+ phases=phases,
+ approval_values=approval_values)
+ self.assertEqual(789, actual_issue.project_id)
+ self.assertEqual('sum', actual_issue.summary)
+ self.assertEqual('New', actual_issue.status)
+ self.assertEqual(111, actual_issue.reporter_id)
+ self.assertEqual(111, actual_issue.owner_id)
+ self.assertEqual([333], actual_issue.cc_ids)
+ self.assertEqual([], actual_issue.field_values)
+ self.assertEqual([], actual_issue.component_ids)
+ self.assertEqual(approval_values, actual_issue.approval_values)
+ self.assertEqual(phases, actual_issue.phases)
+ self.assertEqual('desc', comment.content)
+ loaded_comments = self.services.issue.GetCommentsForIssue(
+ self.cnxn, actual_issue.issue_id)
+ self.assertEqual('desc', loaded_comments[0].content)
+
+ # Verify that an indexing task was enqueued for this issue:
+ self.assertTrue(self.services.issue.enqueue_issues_called)
+ self.assertEqual(1, len(self.services.issue.enqueued_issues))
+ self.assertEqual(actual_issue.issue_id,
+ self.services.issue.enqueued_issues[0])
+
+ # Verify that tasks were queued to send email notifications.
+ hostport = 'testing-app.appspot.com'
+ fake_pasicn.assert_called_once_with(
+ actual_issue.issue_id, hostport, 111, comment_id=comment.id)
+ fake_pasibn.assert_called_once_with(
+ actual_issue.issue_id, hostport, [], 111)
+
+ @mock.patch(
+ 'settings.preferred_domains', {'testing-app.appspot.com': 'example.com'})
+ @mock.patch(
+ 'settings.branded_domains', {'proj': 'branded.com'})
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_Branded(self, fake_pasicn, fake_pasibn):
+ """Use branded domains in notification about creating an issue."""
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ actual_issue, comment = we.CreateIssue(
+ 789, 'sum', 'New', 111, [333], ['Hot'], [], [], 'desc')
+
+ self.assertEqual('proj', actual_issue.project_name)
+ # Verify that tasks were queued to send email notifications.
+ hostport = 'branded.com'
+ fake_pasicn.assert_called_once_with(
+ actual_issue.issue_id, hostport, 111, comment_id=comment.id)
+ fake_pasibn.assert_called_once_with(
+ actual_issue.issue_id, hostport, [], 111)
+
+ @mock.patch(
+ 'settings.preferred_domains', {'testing-app.appspot.com': 'example.com'})
+ @mock.patch(
+ 'settings.branded_domains', {'other-proj': 'branded.com'})
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_Nonbranded(self, fake_pasicn, fake_pasibn):
+ """Don't use branded domains when creating issue in different project."""
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ actual_issue, comment = we.CreateIssue(
+ 789, 'sum', 'New', 111, [333], ['Hot'], [], [], 'desc')
+
+ self.assertEqual('proj', actual_issue.project_name)
+ # Verify that tasks were queued to send email notifications.
+ hostport = 'example.com'
+ fake_pasicn.assert_called_once_with(
+ actual_issue.issue_id, hostport, 111, comment_id=comment.id)
+ fake_pasibn.assert_called_once_with(
+ actual_issue.issue_id, hostport, [], 111)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_DontSendEmail(self, fake_pasicn, fake_pasibn):
+ """We can create an issue, without queueing notification tasks."""
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ actual_issue, comment = we.CreateIssue(
+ 789,
+ 'sum',
+ 'New',
+ 111, [333], ['Hot'], [], [],
+ 'desc',
+ send_email=False)
+ self.assertEqual(789, actual_issue.project_id)
+ self.assertEqual('sum', actual_issue.summary)
+ self.assertEqual('New', actual_issue.status)
+ self.assertEqual('desc', comment.content)
+
+ # Verify that tasks were not queued to send email notifications.
+ self.assertEqual([], fake_pasicn.mock_calls)
+ self.assertEqual([], fake_pasibn.mock_calls)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_ImportedIssue_Allowed(self, _fake_pasicn, _fake_pasibn):
+ """We can create an imported issue, if the requester has permission."""
+ PAST_TIME = 123456
+ self.project.extra_perms = [project_pb2.Project.ExtraPerms(
+ member_id=111, perms=['ImportComment'])]
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ actual_issue, comment = we.CreateIssue(
+ 789,
+ 'sum',
+ 'New',
+ 111, [333], ['Hot'], [], [],
+ 'desc',
+ send_email=False,
+ reporter_id=222,
+ timestamp=PAST_TIME)
+ self.assertEqual(789, actual_issue.project_id)
+ self.assertEqual('sum', actual_issue.summary)
+ self.assertEqual(222, actual_issue.reporter_id)
+ self.assertEqual(PAST_TIME, actual_issue.opened_timestamp)
+ self.assertEqual(222, comment.user_id)
+ self.assertEqual(111, comment.importer_id)
+ self.assertEqual(PAST_TIME, comment.timestamp)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_ImportedIssue_Denied(self, _fake_pasicn, _fake_pasibn):
+ """We can refuse to import an issue, if requester lacks permission."""
+ PAST_TIME = 123456
+ # Note: no "ImportComment" permission is granted.
+ self.SignIn(user_id=111)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CreateIssue(
+ 789, 'sum', 'New', 222, [333], ['Hot'], [], [], 'desc',
+ send_email=False, reporter_id=222, timestamp=PAST_TIME)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_OnwerValidation(self, _fake_pasicn, _fake_pasibn):
+ """We validate the owner."""
+ self.SignIn(user_id=111)
+ with self.assertRaisesRegexp(exceptions.InputException,
+ 'Issue owner must be a project member'):
+ with self.work_env as we:
+ # user_id 222 is not a project member
+ we.CreateIssue(789, 'sum', 'New', 222, [333], ['Hot'], [], [], 'desc')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_SummaryValidation(self, _fake_pasicn, _fake_pasibn):
+ """We validate the summary."""
+ self.SignIn(user_id=111)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ # Summary cannot be empty
+ we.CreateIssue(789, '', 'New', 111, [333], ['Hot'], [], [], 'desc')
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ # Summary cannot be only spaces
+ we.CreateIssue(789, ' ', 'New', 111, [333], ['Hot'], [], [], 'desc')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_DescriptionValidation(self, _fake_pasicn, _fake_pasibn):
+ """We validate the description."""
+ self.SignIn(user_id=111)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ # Description cannot be empty
+ we.CreateIssue(789, 'sum', 'New', 111, [333], ['Hot'], [], [], '')
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ # Description cannot be only spaces
+ we.CreateIssue(789, 'sum', 'New', 111, [333], ['Hot'], [], [], ' ')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_FieldValueValidation(self, _fake_pasicn, _fake_pasibn):
+ """We validate field values against field definitions."""
+ self.SignIn(user_id=111)
+ # field_def_1 has a max of 10.
+ fv = fake.MakeFieldValue(field_id=self.field_def_1.field_id, int_value=11)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CreateIssue(789, 'sum', 'New', 111, [], [], [fv], [], '')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_AppliesFilterRules(self, _fake_pasicn, _fake_pasibn):
+ """We apply filter rules."""
+ self.services.features.TestAddFilterRule(
+ 789, '-has:component', add_labels=['no-component'])
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ actual_issue, _ = we.CreateIssue(
+ 789, 'sum', 'New', 111, [333], [], [], [], 'desc')
+ self.assertEqual(len(actual_issue.derived_labels), 1)
+ self.assertEqual(actual_issue.derived_labels[0], 'no-component')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_RaiseFilterErrors(self, _fake_pasicn, _fake_pasibn):
+ """We raise FilterRuleException if filter rule should show error."""
+ self.services.features.TestAddFilterRule(789, '-has:component', error='er')
+ PAST_TIME = 123456
+ self.SignIn(user_id=111)
+ with self.assertRaises(exceptions.FilterRuleException):
+ with self.work_env as we:
+ we.CreateIssue(
+ 789,
+ 'sum',
+ 'New',
+ 111, [], [], [], [],
+ 'desc',
+ send_email=False,
+ timestamp=PAST_TIME)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testCreateIssue_IgnoresFilterErrors(self, _fake_pasicn, _fake_pasibn):
+ """We can apply filter rules and ignore resulting errors."""
+ self.services.features.TestAddFilterRule(789, '-has:component', error='er')
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ actual_issue, _ = we.CreateIssue(
+ 789,
+ 'sum',
+ 'New',
+ 111, [], [], [], [],
+ 'desc',
+ send_email=False,
+ raise_filter_errors=False)
+ self.assertEqual(len(actual_issue.component_ids), 0)
+
+ def testMakeIssueFromDelta(self):
+ # TODO(crbug/monorail/7197): implement tests
+ pass
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testMakeIssue_Normal(self, _fake_pasicn, _fake_pasibn):
+ self.SignIn(user_id=111)
+ fd_id = self.services.config.CreateFieldDef(
+ self.cnxn,
+ self.project.project_id,
+ 'Restricted-Foo',
+ 'STR_TYPE',
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None, [], [111],
+ is_restricted_field=True)
+ input_fv = tracker_pb2.FieldValue(field_id=fd_id, str_value='Bar')
+ input_issue = tracker_pb2.Issue(
+ project_id=789,
+ owner_id=111,
+ summary='sum',
+ status='New',
+ field_values=[input_fv])
+ with self.work_env as we:
+ actual_issue = we.MakeIssue(input_issue, 'description', False)
+ self.assertEqual(actual_issue.project_id, 789)
+ self.assertEqual(actual_issue.summary, 'sum')
+ self.assertEqual(actual_issue.status, 'New')
+ self.assertEqual(actual_issue.reporter_id, 111)
+ self.assertEqual(actual_issue.field_values, [input_fv])
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testMakeIssue_ChecksRestrictedFields(self, _fake_pasicn, _fake_pasibn):
+ self.SignIn(user_id=222)
+ fd_id = self.services.config.CreateFieldDef(
+ self.cnxn,
+ self.project.project_id,
+ 'Restricted-Foo',
+ 'STR_TYPE',
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None, [], [111],
+ is_restricted_field=True)
+ input_fv = tracker_pb2.FieldValue(field_id=fd_id, str_value='Bar')
+ input_issue = tracker_pb2.Issue(
+ project_id=789, summary='sum', status='New', field_values=[input_fv])
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.MakeIssue(input_issue, 'description', False)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testMakeIssue_ChecksRestrictedLabels(self, _fake_pasicn, _fake_pasibn):
+ """Also checks restricted field that are masked as labels."""
+ self.SignIn(user_id=222)
+ self.services.config.CreateFieldDef(
+ self.cnxn,
+ self.project.project_id,
+ 'Rfoo',
+ 'ENUM_TYPE',
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None, [], [111],
+ is_restricted_field=True)
+ input_issue = tracker_pb2.Issue(
+ project_id=789, summary='sum', status='New', labels=['Rfoo-bar'])
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.MakeIssue(input_issue, 'description', False)
+
+ @mock.patch('services.tracker_fulltext.IndexIssues')
+ @mock.patch('services.tracker_fulltext.UnindexIssues')
+ def testMoveIssue_Normal(self, mock_unindex, mock_index):
+ """We can move issues."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988, committer_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ moved_issue = we.MoveIssue(issue, target_project)
+
+ self.assertEqual(moved_issue.project_name, 'dest')
+ self.assertEqual(moved_issue.local_id, 1)
+
+ moved_issue = self.services.issue.GetIssueByLocalID(
+ 'cnxn', target_project.project_id, 1)
+ self.assertEqual(target_project.project_id, moved_issue.project_id)
+ self.assertEqual(issue.summary, moved_issue.summary)
+ self.assertEqual(moved_issue.reporter_id, 111)
+
+ mock_unindex.assert_called_once_with([issue.issue_id])
+ mock_index.assert_called_once_with(
+ self.mr.cnxn, [issue], self.services.user, self.services.issue,
+ self.services.config)
+
+ @mock.patch('services.tracker_fulltext.IndexIssues')
+ @mock.patch('services.tracker_fulltext.UnindexIssues')
+ def testMoveIssue_MoveBackAgain(self, _mock_unindex, _mock_index):
+ """We can move issues backt and get the old id."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ issue.project_name = 'proj'
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988, owner_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ moved_issue = we.MoveIssue(issue, target_project)
+ moved_issue = we.MoveIssue(moved_issue, self.project)
+
+ self.assertEqual(moved_issue.project_name, 'proj')
+ self.assertEqual(moved_issue.local_id, 1)
+
+ moved_issue = self.services.issue.GetIssueByLocalID(
+ 'cnxn', self.project.project_id, 1)
+ self.assertEqual(self.project.project_id, moved_issue.project_id)
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ self.assertEqual(
+ comments[1].content, 'Moved issue proj:1 to now be issue dest:1.')
+ self.assertEqual(
+ comments[2].content, 'Moved issue dest:1 back to issue proj:1 again.')
+
+ def testMoveIssue_Anon(self):
+ """Anon can't move issues."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988)
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.MoveIssue(issue, target_project)
+
+ def testMoveIssue_CantDeleteIssue(self):
+ """We can't move issues if we don't have DeleteIssue perm on the issue."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988, committer_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.MoveIssue(issue, target_project)
+
+ def testMoveIssue_CantEditIssueOnTargetProject(self):
+ """We can't move issues if we don't have EditIssue perm on target."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=989)
+
+ self.SignIn(user_id=111)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.MoveIssue(issue, target_project)
+
+ def testMoveIssue_CantRestrictions(self):
+ """We can't move issues if they have restriction labels."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ issue.labels = ['Restrict-Foo-Bar']
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=989, committer_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.MoveIssue(issue, target_project)
+
+ def testMoveIssue_TooLongIssue(self):
+ """We can't move issues if the comment is too long."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988, committer_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.MoveIssue(issue, target_project)
+
+ @mock.patch('services.tracker_fulltext.IndexIssues')
+ def testCopyIssue_Normal(self, mock_index):
+ """We can copy issues."""
+ issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, issue_id=78901, project_name='proj')
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988, committer_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ copied_issue = we.CopyIssue(issue, target_project)
+
+ self.assertEqual(copied_issue.project_name, 'dest')
+ self.assertEqual(copied_issue.local_id, 1)
+
+ # Original issue should still exist.
+ self.services.issue.GetIssueByLocalID('cnxn', 789, 1)
+
+ copied_issue = self.services.issue.GetIssueByLocalID(
+ 'cnxn', target_project.project_id, 1)
+ self.assertEqual(target_project.project_id, copied_issue.project_id)
+ self.assertEqual(issue.summary, copied_issue.summary)
+ self.assertEqual(copied_issue.reporter_id, 111)
+
+ mock_index.assert_called_once_with(
+ self.mr.cnxn, [copied_issue], self.services.user, self.services.issue,
+ self.services.config)
+
+ comment = self.services.issue.GetCommentsForIssue(
+ 'cnxn', copied_issue.issue_id)[-1]
+ self.assertEqual(1, len(comment.amendments))
+ amendment = comment.amendments[0]
+ self.assertEqual(
+ tracker_pb2.Amendment(
+ field=tracker_pb2.FieldID.PROJECT,
+ newvalue='dest',
+ added_user_ids=[],
+ removed_user_ids=[]),
+ amendment)
+
+ @mock.patch('services.tracker_fulltext.IndexIssues')
+ def testCopyIssue_SameProject(self, mock_index):
+ """We can copy issues."""
+ issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, issue_id=78901, project_name='proj')
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.project
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ copied_issue = we.CopyIssue(issue, target_project)
+
+ self.assertEqual(copied_issue.project_name, 'proj')
+ self.assertEqual(copied_issue.local_id, 2)
+
+ # Original issue should still exist.
+ self.services.issue.GetIssueByLocalID('cnxn', 789, 1)
+
+ copied_issue = self.services.issue.GetIssueByLocalID(
+ 'cnxn', target_project.project_id, 2)
+ self.assertEqual(target_project.project_id, copied_issue.project_id)
+ self.assertEqual(issue.summary, copied_issue.summary)
+ self.assertEqual(copied_issue.reporter_id, 111)
+
+ mock_index.assert_called_once_with(
+ self.mr.cnxn, [copied_issue], self.services.user, self.services.issue,
+ self.services.config)
+ comment = self.services.issue.GetCommentsForIssue(
+ 'cnxn', copied_issue.issue_id)[-1]
+ self.assertEqual(0, len(comment.amendments))
+
+ def testCopyIssue_Anon(self):
+ """Anon can't copy issues."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988)
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CopyIssue(issue, target_project)
+
+ def testCopyIssue_CantDeleteIssue(self):
+ """We can't copy issues if we don't have DeleteIssue perm on the issue."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=988, committer_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CopyIssue(issue, target_project)
+
+ def testCopyIssue_CantEditIssueOnTargetProject(self):
+ """We can't copy issues if we don't have EditIssue perm on target."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=989)
+
+ self.SignIn(user_id=111)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CopyIssue(issue, target_project)
+
+ def testCopyIssue_CantRestrictions(self):
+ """We can't copy issues if they have restriction labels."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ issue.labels = ['Restrict-Foo-Bar']
+ self.services.issue.TestAddIssue(issue)
+ self.project.owner_ids = [111]
+ target_project = self.services.project.TestAddProject(
+ 'dest', project_id=989, committer_ids=[111])
+
+ self.SignIn(user_id=111)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CopyIssue(issue, target_project)
+
+ @mock.patch('search.frontendsearchpipeline.FrontendSearchPipeline')
+ def testSearchIssues(self, mocked_pipeline):
+ mocked_instance = mocked_pipeline.return_value
+ mocked_instance.total_count = 10
+ mocked_instance.visible_results = ['a', 'b']
+ with self.work_env as we:
+ actual = we.SearchIssues('', ['proj'], 123, 20, 0, '')
+ expected = work_env.ListResult(['a', 'b'], None)
+ self.assertEqual(actual, expected)
+
+ @mock.patch('search.frontendsearchpipeline.FrontendSearchPipeline')
+ def testSearchIssues_paginates(self, mocked_pipeline):
+ mocked_instance = mocked_pipeline.return_value
+ mocked_instance.total_count = 50
+ mocked_instance.visible_results = ['a', 'b']
+ with self.work_env as we:
+ actual = we.SearchIssues('', ['proj'], 123, 20, 0, '')
+ expected = work_env.ListResult(['a', 'b'], 20)
+ self.assertEqual(actual, expected)
+
+ @mock.patch('search.frontendsearchpipeline.FrontendSearchPipeline')
+ def testSearchIssues_NoSuchProject(self, mocked_pipeline):
+ mocked_instance = mocked_pipeline.return_value
+ mocked_instance.total_count = 10
+ mocked_instance.visible_results = ['a', 'b']
+
+ with self.assertRaises(exceptions.NoSuchProjectException):
+ with self.work_env as we:
+ we.SearchIssues('', ['chicken'], 123, 20, 0, '')
+
+ @mock.patch('search.frontendsearchpipeline.FrontendSearchPipeline')
+ def testListIssues_Normal(self, mocked_pipeline):
+ """We can do a query that generates some results."""
+ mocked_instance = mocked_pipeline.return_value
+ with self.work_env as we:
+ actual = we.ListIssues('', ['a'], 123, 20, 0, 1, '', '', True)
+ self.assertEqual(actual, mocked_instance)
+ mocked_instance.SearchForIIDs.assert_called_once()
+ mocked_instance.MergeAndSortIssues.assert_called_once()
+ mocked_instance.Paginate.assert_called_once()
+
+ def testListIssues_Error(self):
+ """Errors are safely reported."""
+ pass # TODO(jrobbins): add unit test
+
+ def testFindIssuePositionInSearch_Normal(self):
+ """We can find an issue position for the flipper."""
+ pass # TODO(jrobbins): add unit test
+
+ def testFindIssuePositionInSearch_Error(self):
+ """Errors are safely reported."""
+ pass # TODO(jrobbins): add unit test
+
+ def testGetIssuesDict_Normal(self):
+ """We can get an existing issue by issue_id."""
+ issue_1 = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue_1)
+ issue_2 = fake.MakeTestIssue(789, 2, 'sum', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue_2)
+
+ with self.work_env as we:
+ actual = we.GetIssuesDict([78901, 78902])
+
+ self.assertEqual({78901: issue_1, 78902: issue_2}, actual)
+
+ def testGetIssuesDict_NoPermission(self):
+ """We reject attempts to get issues the user cannot view."""
+ issue_1 = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ issue_1.labels = ['Restrict-View-CoreTeam']
+ issue_1.project_name = 'farm-proj'
+ self.services.issue.TestAddIssue(issue_1)
+ issue_2 = fake.MakeTestIssue(789, 2, 'sum', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue_2)
+ issue_3 = fake.MakeTestIssue(789, 3, 'sum', 'New', 111, issue_id=78903)
+ issue_3.labels = ['Restrict-View-CoreTeam']
+ issue_3.project_name = 'farm-proj'
+ self.services.issue.TestAddIssue(issue_3)
+ with self.assertRaisesRegexp(
+ permissions.PermissionException,
+ 'User is not allowed to view issue: farm-proj:1.\n' +
+ 'User is not allowed to view issue: farm-proj:3.'):
+ with self.work_env as we:
+ we.GetIssuesDict([78901, 78902, 78903])
+
+ def testGetIssuesDict_NoSuchIssue(self):
+ """We reject attempts to get a non-existent issue."""
+ issue_1 = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue_1)
+ with self.assertRaisesRegexp(exceptions.NoSuchIssueException,
+ 'No such issue: 78902\nNo such issue: 78903'):
+ with self.work_env as we:
+ _actual = we.GetIssuesDict([78901, 78902, 78903])
+
+ def testGetIssue_Normal(self):
+ """We can get an existing issue by issue_id."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ with self.work_env as we:
+ actual = we.GetIssue(78901)
+
+ self.assertEqual(issue, actual)
+
+ def testGetIssue_NoPermission(self):
+ """We reject attempts to get an issue we don't have permission for."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ issue.labels = ['Restrict-View-CoreTeam']
+ self.services.issue.TestAddIssue(issue)
+
+ # We should get a permission exception
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ _actual = we.GetIssue(78901)
+
+ # ...unless we have permission to see the issue
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ actual = we.GetIssue(78901)
+ self.assertEqual(issue, actual)
+
+ def testGetIssue_NoneIssue(self):
+ """We reject attempts to get a none issue."""
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ _actual = we.GetIssue(None)
+
+ def testGetIssue_NoSuchIssue(self):
+ """We reject attempts to get a non-existent issue."""
+ with self.assertRaises(exceptions.NoSuchIssueException):
+ with self.work_env as we:
+ _actual = we.GetIssue(78901)
+
+ def testListReferencedIssues(self):
+ """We return only existing or visible issues even w/out project names."""
+ ref_tuples = [
+ (None, 1), ('other-proj', 1), ('proj', 99),
+ ('ghost-proj', 1), ('proj', 42), ('other-proj', 1)]
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ private = fake.MakeTestIssue(789, 42, 'sum', 'New', 422, issue_id=78942)
+ private.labels.append('Restrict-View-CoreTeam')
+ self.services.issue.TestAddIssue(private)
+ self.services.project.TestAddProject(
+ 'other-proj', project_id=788)
+ other_issue = fake.MakeTestIssue(
+ 788, 1, 'sum', 'Fixed', 111, issue_id=78801)
+ self.services.issue.TestAddIssue(other_issue)
+
+ with self.work_env as we:
+ actual_open, actual_closed = we.ListReferencedIssues(ref_tuples, 'proj')
+
+ self.assertEqual([issue], actual_open)
+ self.assertEqual([other_issue], actual_closed)
+
+ def testListReferencedIssues_PreservesOrder(self):
+ ref_tuples = [('proj', i) for i in range(1, 10)]
+ # Duplicate some ref_tuples. The result should have no duplicated issues,
+ # with only the first occurrence being preserved.
+ ref_tuples += [('proj', 1), ('proj', 5)]
+ expected_open = [
+ fake.MakeTestIssue(789, i, 'sum', 'New', 111) for i in range(1, 5)]
+ expected_closed = [
+ fake.MakeTestIssue(789, i, 'sum', 'Fixed', 111) for i in range(5, 10)]
+ for issue in expected_open + expected_closed:
+ self.services.issue.TestAddIssue(issue)
+
+ with self.work_env as we:
+ actual_open, actual_closed = we.ListReferencedIssues(ref_tuples, 'proj')
+
+ self.assertEqual(expected_open, actual_open)
+ self.assertEqual(expected_closed, actual_closed)
+
+ def testGetIssueByLocalID_Normal(self):
+ """We can get an existing issue by project_id and local_id."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ with self.work_env as we:
+ actual = we.GetIssueByLocalID(789, 1)
+
+ self.assertEqual(issue, actual)
+
+ def testGetIssueByLocalID_ProjectNotSpecified(self):
+ """We reject calls with missing information."""
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ _actual = we.GetIssueByLocalID(None, 1)
+
+ def testGetIssueByLocalID_IssueNotSpecified(self):
+ """We reject calls with missing information."""
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ _actual = we.GetIssueByLocalID(789, None)
+
+ def testGetIssueByLocalID_NoSuchIssue(self):
+ """We reject attempts to get a non-existent issue."""
+ with self.assertRaises(exceptions.NoSuchIssueException):
+ with self.work_env as we:
+ _actual = we.GetIssueByLocalID(789, 1)
+
+ def testGetRelatedIssueRefs_None(self):
+ """We handle issues that have no related issues."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111)
+ self.services.issue.TestAddIssue(issue)
+
+ with self.work_env as we:
+ actual = we.GetRelatedIssueRefs([issue])
+
+ self.assertEqual({}, actual)
+
+ def testGetRelatedIssueRefs_Some(self):
+ """We can get refs for related issues of a given issue."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111)
+ sooner = fake.MakeTestIssue(789, 2, 'sum', 'New', 111, project_name='proj')
+ later = fake.MakeTestIssue(789, 3, 'sum', 'New', 111, project_name='proj')
+ better = fake.MakeTestIssue(789, 4, 'sum', 'New', 111, project_name='proj')
+ issue.blocked_on_iids.append(sooner.issue_id)
+ issue.blocking_iids.append(later.issue_id)
+ issue.merged_into = better.issue_id
+ self.services.issue.TestAddIssue(issue)
+ self.services.issue.TestAddIssue(sooner)
+ self.services.issue.TestAddIssue(later)
+ self.services.issue.TestAddIssue(better)
+
+ with self.work_env as we:
+ actual = we.GetRelatedIssueRefs([issue])
+
+ self.assertEqual(
+ {sooner.issue_id: ('proj', 2),
+ later.issue_id: ('proj', 3),
+ better.issue_id: ('proj', 4)},
+ actual)
+
+ def testGetRelatedIssueRefs_MultipleIssues(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111)
+ blocking = fake.MakeTestIssue(
+ 789, 2, 'sum', 'New', 111, project_name='proj')
+ issue2 = fake.MakeTestIssue(789, 3, 'sum', 'New', 111, project_name='proj')
+ blocked_on = fake.MakeTestIssue(
+ 789, 4, 'sum', 'New', 111, project_name='proj')
+ issue3 = fake.MakeTestIssue(789, 5, 'sum', 'New', 111, project_name='proj')
+ merged_into = fake.MakeTestIssue(
+ 789, 6, 'sum', 'New', 111, project_name='proj')
+
+ issue.blocked_on_iids.append(blocked_on.issue_id)
+ issue2.blocking_iids.append(blocking.issue_id)
+ issue3.merged_into = merged_into.issue_id
+
+ self.services.issue.TestAddIssue(issue)
+ self.services.issue.TestAddIssue(issue2)
+ self.services.issue.TestAddIssue(issue3)
+ self.services.issue.TestAddIssue(blocked_on)
+ self.services.issue.TestAddIssue(blocking)
+ self.services.issue.TestAddIssue(merged_into)
+
+ with self.work_env as we:
+ actual = we.GetRelatedIssueRefs([issue, issue2, issue3])
+
+ self.assertEqual(
+ {blocking.issue_id: ('proj', 2),
+ blocked_on.issue_id: ('proj', 4),
+ merged_into.issue_id: ('proj', 6)},
+ actual)
+
+ def testGetIssueRefs(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, project_name='proj1')
+ issue2 = fake.MakeTestIssue(789, 3, 'sum', 'New', 111, project_name='proj')
+ issue3 = fake.MakeTestIssue(789, 5, 'sum', 'New', 111, project_name='proj')
+
+ self.services.issue.TestAddIssue(issue)
+ self.services.issue.TestAddIssue(issue2)
+ self.services.issue.TestAddIssue(issue3)
+
+ with self.work_env as we:
+ actual = we.GetIssueRefs(
+ [issue.issue_id, issue2.issue_id, issue3.issue_id])
+
+ self.assertEqual(
+ {issue.issue_id: ('proj1', 1),
+ issue2.issue_id: ('proj', 3),
+ issue3.issue_id: ('proj', 5)},
+ actual)
+
+ @mock.patch('businesslogic.work_env.WorkEnv.UpdateIssueApproval')
+ def testBulkUpdateIssueApprovals(self, mockUpdateIssueApproval):
+ updated_issues = [78901, 78902]
+ def side_effect(issue_id, *_args, **_kwargs):
+ if issue_id in [78903]:
+ raise permissions.PermissionException
+ if issue_id in [78904, 78905]:
+ raise exceptions.NoSuchIssueApprovalException
+ mockUpdateIssueApproval.side_effect = side_effect
+
+ self.SignIn()
+
+ approval_delta = tracker_pb2.ApprovalDelta()
+ issue_ids = self.work_env.BulkUpdateIssueApprovals(
+ [78901, 78902, 78903, 78904, 78905], 24, self.project, approval_delta,
+ 'comment', send_email=True)
+ self.assertEqual(issue_ids, updated_issues)
+ updateIssueApprovalCalls = [
+ mock.call(
+ 78901, 24, approval_delta, 'comment', False, send_email=False),
+ mock.call(
+ 78902, 24, approval_delta, 'comment', False, send_email=False),
+ mock.call(
+ 78903, 24, approval_delta, 'comment', False, send_email=False),
+ mock.call(
+ 78904, 24, approval_delta, 'comment', False, send_email=False),
+ mock.call(
+ 78905, 24, approval_delta, 'comment', False, send_email=False),
+ ]
+ self.assertEqual(
+ mockUpdateIssueApproval.call_count, len(updateIssueApprovalCalls))
+ mockUpdateIssueApproval.assert_has_calls(updateIssueApprovalCalls)
+
+ def testBulkUpdateIssueApprovals_AnonUser(self):
+ approval_delta = tracker_pb2.ApprovalDelta()
+ with self.assertRaises(permissions.PermissionException):
+ self.work_env.BulkUpdateIssueApprovals(
+ [], 24, self.project, approval_delta,
+ 'comment', send_email=True)
+
+ def testBulkUpdateIssueApprovals_UserLacksViewPerms(self):
+ approval_delta = tracker_pb2.ApprovalDelta()
+ self.SignIn(222)
+ self.project.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ with self.assertRaises(permissions.PermissionException):
+ self.work_env.BulkUpdateIssueApprovals(
+ [], 24, self.project, approval_delta,
+ 'comment', send_email=True)
+
+ @mock.patch('businesslogic.work_env.WorkEnv.UpdateIssueApproval')
+ def testBulkUpdateIssueApprovalsV3(self, mockUpdateIssueApproval):
+
+ def side_effect(issue_id, approval_id, *_args, **_kwargs):
+ return (
+ tracker_pb2.ApprovalValue(approval_id=approval_id),
+ tracker_pb2.IssueComment(issue_id=issue_id),
+ tracker_pb2.Issue(issue_id=issue_id))
+
+ mockUpdateIssueApproval.side_effect = side_effect
+
+ self.SignIn()
+
+ approval_delta = tracker_pb2.ApprovalDelta()
+ approval_delta_2 = tracker_pb2.ApprovalDelta(approver_ids_add=[111])
+ deltas_by_issue = [
+ (78901, 1, approval_delta),
+ (78901, 1, approval_delta),
+ (78901, 2, approval_delta),
+ (78901, 2, approval_delta_2),
+ (78902, 24, approval_delta),
+ ]
+ updated_approval_values = self.work_env.BulkUpdateIssueApprovalsV3(
+ deltas_by_issue, 'xyz', send_email=True)
+ expected = []
+ for iid, aid, _delta in deltas_by_issue:
+ issue_approval_value_pair = (
+ tracker_pb2.Issue(issue_id=iid),
+ tracker_pb2.ApprovalValue(approval_id=aid))
+ expected.append(issue_approval_value_pair)
+
+ self.assertEqual(updated_approval_values, expected)
+ updateIssueApprovalCalls = []
+ for iid, aid, delta in deltas_by_issue:
+ mock_call = mock.call(
+ iid, aid, delta, 'xyz', False, send_email=True, update_perms=True)
+ updateIssueApprovalCalls.append(mock_call)
+ self.assertEqual(mockUpdateIssueApproval.call_count, len(deltas_by_issue))
+ mockUpdateIssueApproval.assert_has_calls(updateIssueApprovalCalls)
+
+ @mock.patch('businesslogic.work_env.WorkEnv.UpdateIssueApproval')
+ def testBulkUpdateIssueApprovalsV3_PermError(self, mockUpdateIssueApproval):
+ mockUpdateIssueApproval.side_effect = mock.Mock(
+ side_effect=permissions.PermissionException())
+ approval_delta = tracker_pb2.ApprovalDelta()
+ deltas_by_issue = [(78901, 1, approval_delta)]
+ with self.assertRaises(permissions.PermissionException):
+ self.work_env.BulkUpdateIssueApprovalsV3(
+ deltas_by_issue, 'comment', send_email=True)
+
+ @mock.patch('businesslogic.work_env.WorkEnv.UpdateIssueApproval')
+ def testBulkUpdateIssueApprovalsV3_NotFound(self, mockUpdateIssueApproval):
+ mockUpdateIssueApproval.side_effect = mock.Mock(
+ side_effect=exceptions.NoSuchIssueApprovalException())
+ approval_delta = tracker_pb2.ApprovalDelta()
+ deltas_by_issue = [(78901, 1, approval_delta)]
+ with self.assertRaises(exceptions.NoSuchIssueApprovalException):
+ self.work_env.BulkUpdateIssueApprovalsV3(
+ deltas_by_issue, 'comment', send_email=True)
+
+ def testBulkUpdateIssueApprovalsV3_UserLacksViewPerms(self):
+ self.SignIn(222)
+ self.project.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ # No exception raised in v3. Permissions checked in UpdateIssueApprovals.
+ self.work_env.BulkUpdateIssueApprovalsV3([], 'comment', send_email=True)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendApprovalChangeNotification')
+ def testUpdateIssueApproval(self, _mockPrepareAndSend):
+ """We can update an issue's approval_value."""
+
+ self.services.issue.DeltaUpdateIssueApproval = mock.Mock()
+
+ self.SignIn()
+
+ config = fake.MakeTestConfig(789, [], [])
+ self.services.config.StoreConfig('cnxn', config)
+
+ av_24 = tracker_pb2.ApprovalValue(
+ approval_id=24, approver_ids=[111],
+ status=tracker_pb2.ApprovalStatus.NOT_SET, set_on=1234, setter_id=999)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111,
+ issue_id=78901, approval_values=[av_24])
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.ApprovalDelta(
+ status=tracker_pb2.ApprovalStatus.REVIEW_REQUESTED,
+ set_on=2345,
+ approver_ids_add=[222],
+ setter_id=111)
+
+ self.work_env.UpdateIssueApproval(78901, 24, delta, 'please review', False)
+
+ self.services.issue.DeltaUpdateIssueApproval.assert_called_once_with(
+ self.mr.cnxn, 111, config, issue, av_24, delta,
+ comment_content='please review', is_description=False, attachments=None,
+ kept_attachments=None)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendApprovalChangeNotification')
+ def testUpdateIssueApproval_IsDescription(self, _mockPrepareAndSend):
+ """We can update an issue's approval survey."""
+
+ self.services.issue.DeltaUpdateIssueApproval = mock.Mock()
+
+ self.SignIn()
+
+ config = fake.MakeTestConfig(789, [], [])
+ self.services.config.StoreConfig('cnxn', config)
+
+ av_24 = tracker_pb2.ApprovalValue(approval_id=24)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111,
+ issue_id=78901, approval_values=[av_24])
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.ApprovalDelta(setter_id=111)
+ self.work_env.UpdateIssueApproval(78901, 24, delta, 'better response', True)
+
+ self.services.issue.DeltaUpdateIssueApproval.assert_called_once_with(
+ self.mr.cnxn, 111, config, issue, av_24, delta,
+ comment_content='better response', is_description=True,
+ attachments=None, kept_attachments=None)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendApprovalChangeNotification')
+ def testUpdateIssueApproval_Attachments(self, _mockPrepareAndSend):
+ """We can attach files as we many an approval change."""
+ self.services.issue.DeltaUpdateIssueApproval = mock.Mock()
+
+ self.SignIn()
+
+ config = fake.MakeTestConfig(789, [], [])
+ self.services.config.StoreConfig('cnxn', config)
+
+ av_24 = tracker_pb2.ApprovalValue(
+ approval_id=24, approver_ids=[111],
+ status=tracker_pb2.ApprovalStatus.NOT_SET, set_on=1234, setter_id=999)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111,
+ issue_id=78901, approval_values=[av_24])
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.ApprovalDelta(
+ status=tracker_pb2.ApprovalStatus.REVIEW_REQUESTED,
+ set_on=2345,
+ approver_ids_add=[222],
+ setter_id=111)
+ attachments = []
+ self.work_env.UpdateIssueApproval(78901, 24, delta, 'please review', False,
+ attachments=attachments)
+
+ self.services.issue.DeltaUpdateIssueApproval.assert_called_once_with(
+ self.mr.cnxn, 111, config, issue, av_24, delta,
+ comment_content='please review', is_description=False,
+ attachments=attachments, kept_attachments=None)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendApprovalChangeNotification')
+ @mock.patch(
+ 'tracker.tracker_helpers.FilterKeptAttachments')
+ def testUpdateIssueApproval_KeptAttachments(
+ self, mockFilterKeptAttachments, _mockPrepareAndSend):
+ """We can keep attachments from previous descriptions."""
+ self.services.issue.DeltaUpdateIssueApproval = mock.Mock()
+ mockFilterKeptAttachments.return_value = [1, 2]
+
+ self.SignIn()
+
+ config = fake.MakeTestConfig(789, [], [])
+ self.services.config.StoreConfig('cnxn', config)
+
+ av_24 = tracker_pb2.ApprovalValue(
+ approval_id=24, approver_ids=[111],
+ status=tracker_pb2.ApprovalStatus.NOT_SET, set_on=1234, setter_id=999)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111,
+ issue_id=78901, approval_values=[av_24])
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.ApprovalDelta(setter_id=111)
+ with self.work_env as we:
+ we.UpdateIssueApproval(
+ 78901, 24, delta, 'Another Desc', True, kept_attachments=[1, 2, 3])
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ mockFilterKeptAttachments.assert_called_once_with(
+ True, [1, 2, 3], comments, 24)
+ self.services.issue.DeltaUpdateIssueApproval.assert_called_once_with(
+ self.mr.cnxn, 111, config, issue, av_24, delta,
+ comment_content='Another Desc', is_description=True,
+ attachments=None, kept_attachments=[1, 2])
+
+ def testUpdateIssueApproval_TooLongComment(self):
+ """We raise an exception if too long a comment is used when updating an
+ issue's approval value."""
+ self.services.issue.DeltaUpdateIssueApproval = mock.Mock()
+
+ self.SignIn()
+
+ config = fake.MakeTestConfig(789, [], [])
+ self.services.config.StoreConfig('cnxn', config)
+
+ av_24 = tracker_pb2.ApprovalValue(
+ approval_id=24,
+ approver_ids=[111],
+ status=tracker_pb2.ApprovalStatus.NOT_SET,
+ set_on=1234,
+ setter_id=999)
+ issue = fake.MakeTestIssue(
+ 789,
+ 1,
+ 'summary',
+ 'Available',
+ 111,
+ issue_id=78901,
+ approval_values=[av_24])
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.ApprovalDelta(
+ status=tracker_pb2.ApprovalStatus.REVIEW_REQUESTED,
+ set_on=2345,
+ approver_ids_add=[222])
+
+ with self.assertRaises(exceptions.InputException):
+ long_comment = ' ' + 'c' * tracker_constants.MAX_COMMENT_CHARS + ' '
+ self.work_env.UpdateIssueApproval(78901, 24, delta, long_comment, False)
+
+ def testUpdateIssueApproval_NonExistentUsers(self):
+ """We raise an exception if adding an approver that does not exist."""
+ self.services.issue.DeltaUpdateIssueApproval = mock.Mock()
+
+ self.SignIn()
+
+ config = fake.MakeTestConfig(789, [], [])
+ self.services.config.StoreConfig('cnxn', config)
+
+ av_24 = tracker_pb2.ApprovalValue(
+ approval_id=24,
+ approver_ids=[111],
+ status=tracker_pb2.ApprovalStatus.NOT_SET,
+ set_on=1234,
+ setter_id=999)
+ issue = fake.MakeTestIssue(
+ 789,
+ 1,
+ 'summary',
+ 'Available',
+ 111,
+ issue_id=78901,
+ approval_values=[av_24])
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.ApprovalDelta(
+ status=tracker_pb2.ApprovalStatus.REVIEW_REQUESTED,
+ set_on=2345,
+ approver_ids_add=[9876])
+
+ with self.assertRaisesRegexp(exceptions.InputException,
+ 'users/9876: User does not exist.'):
+ comment = 'stuff'
+ self.work_env.UpdateIssueApproval(78901, 24, delta, comment, False)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testConvertIssueApprovalsTemplate(self, fake_pasicn):
+ """We can convert an issue's approvals to match template's approvals."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111)
+ issue.approval_values = [
+ tracker_pb2.ApprovalValue(
+ approval_id=3,
+ phase_id=4,
+ status=tracker_pb2.ApprovalStatus.APPROVED,
+ approver_ids=[111],
+ ),
+ tracker_pb2.ApprovalValue(
+ approval_id=4,
+ phase_id=5,
+ approver_ids=[111]),
+ tracker_pb2.ApprovalValue(approval_id=6)]
+ issue.phases = [
+ tracker_pb2.Phase(name='Expired', phase_id=4),
+ tracker_pb2.Phase(name='canary', phase_id=3)]
+ issue.field_values = [
+ tracker_bizobj.MakeFieldValue(8, None, 'Pink', None, None, None, False),
+ tracker_bizobj.MakeFieldValue(
+ 9, None, 'Silver', None, None, None, False, phase_id=3),
+ tracker_bizobj.MakeFieldValue(
+ 19, None, 'Orange', None, None, None, False, phase_id=4),
+ ]
+
+ self.services.issue._UpdateIssuesApprovals = mock.Mock()
+ self.SignIn()
+
+ template = testing_helpers.DefaultTemplates()[0]
+ template.approval_values = [
+ tracker_pb2.ApprovalValue(
+ approval_id=3,
+ phase_id=6, # Different phase. Nothing else affected.
+ approver_ids=[222]),
+ # No phase. Nothing else affected.
+ tracker_pb2.ApprovalValue(approval_id=4),
+ # New approval not already found in issue.
+ tracker_pb2.ApprovalValue(
+ approval_id=7,
+ phase_id=5,
+ approver_ids=[222]),
+ ] # No approval 6
+ template.phases = [tracker_pb2.Phase(name='Canary', phase_id=5),
+ tracker_pb2.Phase(name='Stable-Exp', phase_id=6)]
+ self.services.template.GetTemplateByName.return_value = template
+
+ config = self.services.config.GetProjectConfig(self.cnxn, 789)
+ config.approval_defs = [
+ tracker_pb2.ApprovalDef(approval_id=3, survey='Question3'),
+ tracker_pb2.ApprovalDef(approval_id=4, survey='Question4'),
+ tracker_pb2.ApprovalDef(approval_id=7, survey='Question7'),
+ ]
+ config.field_defs = [
+ tracker_pb2.FieldDef(
+ field_id=3, project_id=789, field_name='Cow'),
+ tracker_pb2.FieldDef(
+ field_id=4, project_id=789, field_name='Chicken'),
+ tracker_pb2.FieldDef(
+ field_id=6, project_id=789, field_name='Llama'),
+ tracker_pb2.FieldDef(
+ field_id=7, project_id=789, field_name='Roo'),
+ tracker_pb2.FieldDef(
+ field_id=8, project_id=789, field_name='Salmon'),
+ tracker_pb2.FieldDef(
+ field_id=9, project_id=789, field_name='Tuna', is_phase_field=True),
+ tracker_pb2.FieldDef(
+ field_id=10, project_id=789, field_name='Clown', is_phase_field=True),
+ ]
+ self.work_env.ConvertIssueApprovalsTemplate(
+ config, issue, 'template_name', 'Convert', send_email=False)
+
+ expected_avs = [
+ tracker_pb2.ApprovalValue(
+ approval_id=3,
+ phase_id=6,
+ status=tracker_pb2.ApprovalStatus.APPROVED,
+ approver_ids=[111],
+ ),
+ tracker_pb2.ApprovalValue(
+ approval_id=4,
+ approver_ids=[111]),
+ tracker_pb2.ApprovalValue(
+ approval_id=7,
+ phase_id=5,
+ approver_ids=[222]),
+ ]
+ expected_fvs = [
+ tracker_bizobj.MakeFieldValue(8, None, 'Pink', None, None, None, False),
+ tracker_bizobj.MakeFieldValue(
+ 9, None, 'Silver', None, None, None, False, phase_id=5),
+ ]
+ self.assertEqual(issue.approval_values, expected_avs)
+ self.assertEqual(issue.field_values, expected_fvs)
+ self.assertEqual(issue.phases, template.phases)
+ self.services.template.GetTemplateByName.assert_called_once_with(
+ self.mr.cnxn, 'template_name', 789)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 111, send_email=False,
+ comment_id=mock.ANY)
+
+ def testConvertIssueApprovalsTemplate_NoSuchTemplate(self):
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111)
+ self.services.template.GetTemplateByName.return_value = None
+ config = self.services.config.GetProjectConfig(self.cnxn, 789)
+ with self.assertRaises(exceptions.NoSuchTemplateException):
+ self.work_env.ConvertIssueApprovalsTemplate(
+ config, issue, 'template_name', 'comment')
+
+ def testConvertIssueApprovalsTemplate_TooLongComment(self):
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111)
+ config = self.services.config.GetProjectConfig(self.cnxn, 789)
+ with self.assertRaises(exceptions.InputException):
+ long_comment = ' ' + 'c' * tracker_constants.MAX_COMMENT_CHARS + ' '
+ self.work_env.ConvertIssueApprovalsTemplate(
+ config, issue, 'template_name', long_comment)
+
+ def testConvertIssueApprovalsTemplate_MissingEditPermissions(self):
+ self.SignIn(self.user_2.user_id)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', self.user_1.user_id)
+ config = self.services.config.GetProjectConfig(self.cnxn, 789)
+ with self.assertRaises(permissions.PermissionException):
+ self.work_env.ConvertIssueApprovalsTemplate(
+ config, issue, 'template_name', 'comment')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_Normal(self, fake_pasicn, fake_pasibn):
+ """We can update an issue."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 0)
+ self.services.issue.TestAddIssue(issue)
+
+ fd = tracker_pb2.FieldDef(
+ field_name='CustomField',
+ field_id=1,
+ field_type=tracker_pb2.FieldTypes.STR_TYPE)
+ res_fd = tracker_pb2.FieldDef(
+ field_name='ResField',
+ field_id=2,
+ field_type=tracker_pb2.FieldTypes.STR_TYPE,
+ is_restricted_field=True,
+ admin_ids=[111])
+ res_fd2 = tracker_pb2.FieldDef(
+ field_name='ResEnumField',
+ field_id=3,
+ field_type=tracker_pb2.FieldTypes.ENUM_TYPE,
+ is_restricted_field=True,
+ editor_ids=[111])
+ config = self.services.config.GetProjectConfig(self.cnxn, 789)
+ config.field_defs = [fd, res_fd, res_fd2]
+ self.services.config.StoreConfig(None, config)
+
+ fv = tracker_pb2.FieldValue(field_id=1, str_value='Chicken')
+ res_fv = tracker_pb2.FieldValue(field_id=2, str_value='Dog')
+ delta = tracker_pb2.IssueDelta(
+ owner_id=111,
+ summary='New summary',
+ cc_ids_add=[333],
+ field_vals_add=[fv, res_fv],
+ labels_add=['resenumfield-b'])
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'Getting started')
+
+ self.assertEqual(111, issue.owner_id)
+ self.assertEqual('New summary', issue.summary)
+ self.assertEqual([333], issue.cc_ids)
+ self.assertEqual([fv, res_fv], issue.field_values)
+ self.assertEqual(['resenumfield-b'], issue.labels)
+ self.assertEqual([issue.issue_id], self.services.issue.enqueued_issues)
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertFalse(comment_pb.is_description)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 111, send_email=True,
+ old_owner_id=0, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 111, send_email=True)
+
+ def testUpdateIssue_RejectEditRestrictedField(self):
+ """We can update an issue."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 0)
+ self.services.issue.TestAddIssue(issue)
+
+ fd = tracker_pb2.FieldDef(
+ field_name='CustomField',
+ field_id=1,
+ field_type=tracker_pb2.FieldTypes.STR_TYPE)
+ res_fd = tracker_pb2.FieldDef(
+ field_name='ResField',
+ field_id=2,
+ field_type=tracker_pb2.FieldTypes.STR_TYPE,
+ is_restricted_field=True)
+ res_fd2 = tracker_pb2.FieldDef(
+ field_name='ResEnumField',
+ field_id=3,
+ field_type=tracker_pb2.FieldTypes.ENUM_TYPE,
+ is_restricted_field=True)
+ config = self.services.config.GetProjectConfig(self.cnxn, 789)
+ config.field_defs = [fd, res_fd, res_fd2]
+ self.services.config.StoreConfig(None, config)
+
+ fv = tracker_pb2.FieldValue(field_id=1, str_value='Chicken')
+ res_fv = tracker_pb2.FieldValue(field_id=2, str_value='Dog')
+ delta_res_field_val = tracker_pb2.IssueDelta(
+ owner_id=111,
+ summary='New summary',
+ cc_ids_add=[333],
+ field_vals_add=[fv, res_fv])
+ delta_res_enum = tracker_pb2.IssueDelta(
+ owner_id=111,
+ summary='New summary',
+ cc_ids_add=[333],
+ field_vals_add=[fv],
+ labels_add=['resenumfield-b'])
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta_res_field_val, 'Getting Started')
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta_res_enum, 'Getting Started')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_EditDescription(self, fake_pasicn, fake_pasibn):
+ """We can edit an issue description."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta()
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'New description', is_description=True)
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertTrue(comment_pb.is_description)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 111, send_email=True,
+ old_owner_id=111, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 111, send_email=True)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_NotAllowedToEditDescription(
+ self, fake_pasicn, fake_pasibn):
+ """We cannot edit an issue description without EditIssue permission."""
+ self.SignIn(222)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta()
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'New description', is_description=True)
+
+ fake_pasicn.assert_not_called()
+ fake_pasibn.assert_not_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_EditTooLongComment(self, fake_pasicn, fake_pasibn):
+ """We cannot edit an issue description with too long a comment."""
+ self.SignIn(222)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta()
+
+ with self.assertRaises(exceptions.InputException):
+ long_comment = ' ' + 'c' * tracker_constants.MAX_COMMENT_CHARS + ' '
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, long_comment)
+
+ fake_pasicn.assert_not_called()
+ fake_pasibn.assert_not_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_AddTooLongComment(self, fake_pasicn, fake_pasibn):
+ """We cannot add too long a comment."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta()
+
+ with self.assertRaises(exceptions.InputException):
+ long_comment = ' ' + 'c' * tracker_constants.MAX_COMMENT_CHARS + ' '
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, long_comment)
+
+ fake_pasicn.assert_not_called()
+ fake_pasibn.assert_not_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_AddComment(self, fake_pasicn, fake_pasibn):
+ """We can add a comment."""
+ self.SignIn(222)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta()
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'New description')
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertFalse(comment_pb.is_description)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 222, send_email=True,
+ old_owner_id=111, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 222, send_email=True)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_AddComment_NoEmail(self, fake_pasicn, fake_pasibn):
+ """We can add a comment without sending email."""
+ self.SignIn(222)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta()
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'New description', send_email=False)
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertFalse(comment_pb.is_description)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 222, send_email=False,
+ old_owner_id=111, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 222, send_email=False)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('framework.permissions.GetExtraPerms')
+ def testUpdateIssue_EditOwner(
+ self, fake_extra_perms, fake_pasicn, fake_pasibn):
+ """We can edit the owner with the EditIssueOwner permission."""
+ self.SignIn(222)
+ fake_extra_perms.return_value = [permissions.EDIT_ISSUE_OWNER]
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(owner_id=0)
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, '')
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertFalse(comment_pb.is_description)
+ self.assertEqual(0, issue.owner_id)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 222, send_email=True,
+ old_owner_id=111, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 222, send_email=True)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('framework.permissions.GetExtraPerms')
+ def testUpdateIssue_EditSummary(
+ self, fake_extra_perms, fake_pasicn, fake_pasibn):
+ """We can edit the owner with the EditIssueOwner permission."""
+ self.SignIn(222)
+ fake_extra_perms.return_value = [permissions.EDIT_ISSUE_SUMMARY]
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(summary='New Summary')
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, '')
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertFalse(comment_pb.is_description)
+ self.assertEqual('New Summary', issue.summary)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 222, send_email=True,
+ old_owner_id=111, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 222, send_email=True)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('framework.permissions.GetExtraPerms')
+ def testUpdateIssue_EditStatus(
+ self, fake_extra_perms, fake_pasicn, fake_pasibn):
+ """We can edit the owner with the EditIssueOwner permission."""
+ self.SignIn(222)
+ fake_extra_perms.return_value = [permissions.EDIT_ISSUE_STATUS]
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(status='Fixed')
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, '')
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertFalse(comment_pb.is_description)
+ self.assertEqual('Fixed', issue.status)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 222, send_email=True,
+ old_owner_id=111, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 222, send_email=True)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('framework.permissions.GetExtraPerms')
+ def testUpdateIssue_EditCC(self, fake_extra_perms, _fake_pasicn):
+ """We can edit the owner with the EditIssueOwner permission."""
+ self.SignIn(222)
+ fake_extra_perms.return_value = [permissions.EDIT_ISSUE_CC]
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ issue.cc_ids = [111]
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(cc_ids_add=[222])
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, '')
+
+ self.assertEqual([111, 222], issue.cc_ids)
+ delta = tracker_pb2.IssueDelta(cc_ids_remove=[111])
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, '')
+
+ self.assertEqual([222], issue.cc_ids)
+
+ def testUpdateIssue_BadOwner(self):
+ """We reject new issue owners that don't pass validation."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+
+ # No such user ID.
+ delta = tracker_pb2.IssueDelta(owner_id=555)
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException) as cm:
+ we.UpdateIssue(issue, delta, '')
+ self.assertEqual('Issue owner user ID not found.',
+ cm.exception.message)
+
+ # Not a member
+ delta = tracker_pb2.IssueDelta(owner_id=222)
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException) as cm:
+ we.UpdateIssue(issue, delta, '')
+ self.assertEqual('Issue owner must be a project member.',
+ cm.exception.message)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_MergeInto(self, fake_pasicn, fake_pasibn):
+ """We can merge Issue 1 (merged_issue) into Issue 2 (merged_into_issue),
+ including CCs and starrers."""
+ self.SignIn()
+ merged_issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ merged_into_issue = fake.MakeTestIssue(789, 2, 'summary2', 'Available', 111)
+ self.services.issue.TestAddIssue(merged_issue)
+ self.services.issue.TestAddIssue(merged_into_issue)
+ delta = tracker_pb2.IssueDelta(
+ merged_into=merged_into_issue.issue_id, status='Duplicate')
+
+ merged_issue.cc_ids = [111, 222, 333, 444]
+ self.services.issue_star.SetStarsBatch(
+ 'cnxn', 'service', 'config', merged_issue.issue_id, [111, 222, 333],
+ True)
+ self.services.issue_star.SetStarsBatch(
+ 'cnxn', 'service', 'config', merged_into_issue.issue_id, [555], True)
+ with self.work_env as we:
+ we.UpdateIssue(merged_issue, delta, '')
+
+ merged_into_issue_comments = self.services.issue.GetCommentsForIssue(
+ 'cnxn', merged_into_issue.issue_id)
+
+ # Original issue marked as duplicate.
+ self.assertEqual('Duplicate', merged_issue.status)
+ # Target issue has original issue's CCs.
+ self.assertEqual([444, 333, 222, 111], merged_into_issue.cc_ids)
+ # A comment was added to the target issue.
+ merged_into_issue_comment = merged_into_issue_comments[-1]
+ self.assertEqual(
+ 'Issue 1 has been merged into this issue.',
+ merged_into_issue_comment.content)
+ source_starrers = self.services.issue_star.LookupItemStarrers(
+ 'cnxn', merged_issue.issue_id)
+ self.assertItemsEqual([111, 222, 333], source_starrers)
+ target_starrers = self.services.issue_star.LookupItemStarrers(
+ 'cnxn', merged_into_issue.issue_id)
+ self.assertItemsEqual([111, 222, 333, 555], target_starrers)
+ # Notifications should be sent for both
+ # the merged issue and the merged_into issue.
+ merged_issue_comments = self.services.issue.GetCommentsForIssue(
+ 'cnxn', merged_issue.issue_id)
+ merged_issue_comment = merged_issue_comments[-1]
+ hostport = 'testing-app.appspot.com'
+ execute_calls = [
+ mock.call(
+ merged_into_issue.issue_id,
+ hostport,
+ 111,
+ send_email=True,
+ comment_id=merged_into_issue_comment.id),
+ mock.call(
+ merged_issue.issue_id,
+ hostport,
+ 111,
+ send_email=True,
+ old_owner_id=111,
+ comment_id=merged_issue_comment.id)
+ ]
+ fake_pasicn.assert_has_calls(execute_calls)
+ self.assertEqual(2, fake_pasicn.call_count)
+ fake_pasibn.assert_called_once_with(
+ merged_issue.issue_id, hostport, [], 111, send_email=True)
+
+ def testUpdateIssue_MergeIntoRestrictedIssue(self):
+ """We cannot merge into an issue we cannot view and edit."""
+ self.SignIn(333)
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ issue2 = fake.MakeTestIssue(789, 2, 'summary2', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ self.services.issue.TestAddIssue(issue2)
+
+ delta = tracker_pb2.IssueDelta(
+ merged_into=issue2.issue_id,
+ status='Duplicate')
+
+ issue2.labels = ['Restrict-View-Foo']
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.UpdateIssue(issue, delta, '')
+
+ issue2.labels = ['Restrict-EditIssue-Foo']
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.UpdateIssue(issue, delta, '')
+
+ # Original issue still available.
+ self.assertEqual('Available', issue.status)
+ # Target issue was not modified.
+ self.assertEqual([], issue2.cc_ids)
+ # No comment was added.
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue2.issue_id)
+ self.assertEqual(1, len(comments))
+
+ def testUpdateIssue_MergeIntoItself(self):
+ """We cannot merge an issue into itself."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(
+ merged_into=issue.issue_id,
+ status='Duplicate')
+
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException) as cm:
+ we.UpdateIssue(issue, delta, '')
+ self.assertEqual('Cannot merge an issue into itself.', cm.exception.message)
+
+ # Original issue still available.
+ self.assertEqual('Available', issue.status)
+ # No comment was added.
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ self.assertEqual(1, len(comments))
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_BlockOn(self, fake_pasicn, fake_pasibn):
+ """We can block an issue on an existing issue."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ upstream_issue = fake.MakeTestIssue(789, 2, 'umbrella', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.IssueDelta(blocked_on_add=[upstream_issue.issue_id])
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, '')
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertEqual([upstream_issue.issue_id], issue.blocked_on_iids)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 111, send_email=True,
+ old_owner_id=111, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [upstream_issue.issue_id],
+ 111, send_email=True)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_BlockOnItself(self, fake_pasicn, fake_pasibn):
+ """We cannot block an issue on itself."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+
+ delta = tracker_pb2.IssueDelta(blocked_on_add=[issue.issue_id])
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException) as cm:
+ we.UpdateIssue(issue, delta, '')
+ self.assertEqual('Cannot block an issue on itself.', cm.exception.message)
+
+ delta = tracker_pb2.IssueDelta(blocking_add=[issue.issue_id])
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException) as cm:
+ we.UpdateIssue(issue, delta, '')
+ self.assertEqual('Cannot block an issue on itself.', cm.exception.message)
+
+ # Original issue was not modified.
+ self.assertEqual(0, len(issue.blocked_on_iids))
+ self.assertEqual(0, len(issue.blocking_iids))
+ # No comment was added.
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ self.assertEqual(1, len(comments))
+ fake_pasicn.assert_not_called()
+ fake_pasibn.assert_not_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_Attachments(self, fake_pasicn, fake_pasibn):
+ """We can attach files as we make a change."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 0)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(
+ owner_id=111, summary='New summary', cc_ids_add=[333])
+
+ attachments = []
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'Getting started', attachments=attachments)
+
+ self.assertEqual(111, issue.owner_id)
+ self.assertEqual('New summary', issue.summary)
+ self.assertEqual([333], issue.cc_ids)
+ self.assertEqual([issue.issue_id], self.services.issue.enqueued_issues)
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertEqual([], comment_pb.attachments)
+ fake_pasicn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', 111, send_email=True,
+ old_owner_id=0, comment_id=comment_pb.id)
+ fake_pasibn.assert_called_with(
+ issue.issue_id, 'testing-app.appspot.com', [], 111, send_email=True)
+
+ attachments = [
+ ('README.md', 'readme content', 'text/plain'),
+ ('hello.txt', 'hello content', 'text/plain')]
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'Getting started', attachments=attachments)
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertEqual(2, len(comment_pb.attachments))
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_KeptAttachments(self, _fake_pasicn):
+ """We can attach files as we make a change."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 111)
+ self.services.issue.TestAddIssue(issue)
+
+ # Add some initial attachments
+ delta = tracker_pb2.IssueDelta()
+ attachments = [
+ ('README.md', 'readme content', 'text/plain'),
+ ('hello.txt', 'hello content', 'text/plain')]
+ with self.work_env as we:
+ we.UpdateIssue(
+ issue, delta, 'New Description', attachments=attachments,
+ is_description=True)
+
+ with self.work_env as we:
+ we.UpdateIssue(
+ issue, delta, 'Yet Another Description', is_description=True,
+ kept_attachments=[1, 2, 3])
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ self.assertEqual(1, len(comment_pb.attachments))
+ self.assertEqual('hello.txt', comment_pb.attachments[0].filename)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueBlockingNotification')
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_PermissionDenied(self, fake_pasicn, fake_pasibn):
+ """We reject attempts to update an issue when the user lacks permission."""
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 555)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(
+ owner_id=222, summary='New summary', cc_ids_add=[333])
+
+ with self.work_env as we:
+ # User is not signed in.
+ with self.assertRaises(permissions.PermissionException):
+ we.UpdateIssue(issue, delta, 'I am anon')
+
+ # User signed in to acconut that can view but not edit.
+ self.SignIn(user_id=222)
+ with self.assertRaises(permissions.PermissionException):
+ we.UpdateIssue(issue, delta, 'I am not a project member')
+
+ # User signed in to acconut that can view and edit, but issue
+ # restricts edits to a perm that the user lacks.
+ self.SignIn(user_id=111)
+ issue.labels.append('Restrict-EditIssue-CoreTeam')
+ with self.assertRaises(permissions.PermissionException):
+ we.UpdateIssue(issue, delta, 'I lack CoreTeam')
+
+ fake_pasicn.assert_not_called()
+ fake_pasibn.assert_not_called()
+
+ @mock.patch(
+ 'settings.preferred_domains', {'testing-app.appspot.com': 'example.com'})
+ @mock.patch(
+ 'settings.branded_domains', {'proj': 'branded.com'})
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ def testUpdateIssue_BrandedDomain(self, fake_pasicn):
+ """Updating an issue in project with branded domain uses that domain."""
+ self.SignIn()
+ issue = fake.MakeTestIssue(789, 1, 'summary', 'Available', 0)
+ self.services.issue.TestAddIssue(issue)
+ delta = tracker_pb2.IssueDelta(
+ owner_id=111, summary='New summary', cc_ids_add=[333])
+
+ with self.work_env as we:
+ we.UpdateIssue(issue, delta, 'Getting started')
+
+ comments = self.services.issue.GetCommentsForIssue('cnxn', issue.issue_id)
+ comment_pb = comments[-1]
+ hostport = 'branded.com'
+ fake_pasicn.assert_called_with(
+ issue.issue_id, hostport, 111, send_email=True,
+ old_owner_id=0, comment_id=comment_pb.id)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ @mock.patch('time.time')
+ def testModifyIssues_WeirdDeltas(
+ self, fake_time, fake_bulk_notify, fake_notify):
+ """Test that ModifyIssues does not panic with weird deltas."""
+ fake_time.return_value = self.PAST_TIME
+
+ # Issues merge into each other.
+ issue_merge_a = _Issue(789, 1)
+ issue_merge_b = _Issue(789, 2)
+
+ delta_merge_a = tracker_pb2.IssueDelta(
+ merged_into=issue_merge_b.issue_id, status='Duplicate')
+ delta_merge_b = tracker_pb2.IssueDelta(
+ merged_into=issue_merge_a.issue_id, status='Duplicate')
+
+ exp_merge_a = copy.deepcopy(issue_merge_a)
+ exp_merge_a.merged_into = issue_merge_b.issue_id
+ exp_merge_a.status = 'Duplicate'
+ exp_merge_a.status_modified_timestamp = self.PAST_TIME
+ exp_amendments_merge_a = [
+ tracker_bizobj.MakeStatusAmendment('Duplicate', ''),
+ tracker_bizobj.MakeMergedIntoAmendment(
+ [(issue_merge_b.project_name, issue_merge_b.local_id)], [],
+ default_project_name=issue_merge_a.project_name)
+ ]
+
+ exp_merge_a_imp_content = work_env.MERGE_COMMENT % issue_merge_b.local_id
+ exp_merge_b = copy.deepcopy(issue_merge_b)
+ exp_merge_b.merged_into = exp_merge_a.issue_id
+ exp_merge_b.status = 'Duplicate'
+ exp_merge_b.status_modified_timestamp = self.PAST_TIME
+ exp_amendments_merge_b = [
+ tracker_bizobj.MakeStatusAmendment('Duplicate', ''),
+ tracker_bizobj.MakeMergedIntoAmendment(
+ [(issue_merge_a.project_name, issue_merge_a.local_id)], [],
+ default_project_name=issue_merge_b.project_name)
+ ]
+
+ exp_merge_b_imp_content = work_env.MERGE_COMMENT % issue_merge_a.local_id
+
+ # Issues that block each other.
+ issue_block_a = _Issue(789, 5)
+ issue_block_b = _Issue(789, 6)
+
+ delta_block_a = tracker_pb2.IssueDelta(
+ blocking_add=[issue_block_b.issue_id])
+ delta_block_b = tracker_pb2.IssueDelta(
+ blocking_add=[issue_block_a.issue_id])
+
+ exp_block_a = copy.deepcopy(issue_block_a)
+ exp_block_a.blocking_iids = [issue_block_b.issue_id]
+ exp_block_a.blocked_on_iids = [issue_block_b.issue_id]
+ exp_amendments_block_a = [tracker_bizobj.MakeBlockingAmendment(
+ [(issue_block_b.project_name, issue_block_b.local_id)], [],
+ default_project_name=issue_block_a.project_name)]
+ exp_amendments_block_a_imp = [tracker_bizobj.MakeBlockedOnAmendment(
+ [(issue_block_b.project_name, issue_block_b.local_id)], [],
+ default_project_name=issue_block_a.project_name)]
+
+ exp_block_b = copy.deepcopy(issue_block_b)
+ exp_block_b.blocking_iids = [issue_block_a.issue_id]
+ exp_block_b.blocked_on_iids = [issue_block_a.issue_id]
+ exp_amendments_block_b = [tracker_bizobj.MakeBlockingAmendment(
+ [(issue_block_a.project_name, issue_block_a.local_id)], [],
+ default_project_name=issue_block_b.project_name)]
+ exp_amendments_block_b_imp = [tracker_bizobj.MakeBlockedOnAmendment(
+ [(issue_block_a.project_name, issue_block_a.local_id)], [],
+ default_project_name=issue_block_b.project_name)]
+
+ # 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.
+ exp_block_a.blocked_on_ranks = [0]
+ exp_block_b.blocked_on_ranks = [0]
+
+ self.services.issue.TestAddIssue(issue_merge_a)
+ self.services.issue.TestAddIssue(issue_merge_b)
+ self.services.issue.TestAddIssue(issue_block_a)
+ self.services.issue.TestAddIssue(issue_block_b)
+
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ issue_delta_pairs = [(issue_merge_a.issue_id, delta_merge_a),
+ (issue_merge_b.issue_id, delta_merge_b),
+ (issue_block_a.issue_id, delta_block_a),
+ (issue_block_b.issue_id, delta_block_b)]
+
+ content = 'Je suis un ananas.'
+ self.SignIn(self.user_1.user_id)
+ send_email = False
+ with self.work_env as we:
+ actual_issues = we.ModifyIssues(
+ issue_delta_pairs,
+ False,
+ comment_content=content,
+ send_email=send_email)
+
+ # We expect all issues to have a description comment and the comment(s)
+ # added from the ModifyIssues() changes.
+ def CheckComment(
+ issue_id, exp_amendments, exp_amendments_imp, imp_comment_content=''):
+ (_desc, comment, comment_imp
+ ) = self.services.issue.comments_by_iid[issue_id]
+ self.assertEqual(comment.amendments, exp_amendments)
+ self.assertEqual(comment.content, content)
+ self.assertEqual(comment_imp.amendments, exp_amendments_imp)
+ self.assertEqual(comment_imp.content, imp_comment_content)
+ return comment, comment_imp
+
+ # Merge changes result in a MERGEDINTO Amendment for an
+ # Issue's mergedInto change (e.g. MergedInto: 1)
+ # and comment content for the impacted issue's change (with no amendment).
+ # (e.g. 'Issue 2 has been merged into the this issue.')
+ comment_merge_a, comment_merge_a_imp = CheckComment(
+ issue_merge_a.issue_id,
+ exp_amendments_merge_a, [],
+ imp_comment_content=exp_merge_a_imp_content)
+ comment_merge_b, comment_merge_b_imp = CheckComment(
+ issue_merge_b.issue_id,
+ exp_amendments_merge_b, [],
+ imp_comment_content=exp_merge_b_imp_content)
+
+ comment_block_a, comment_block_a_imp = CheckComment(
+ issue_block_a.issue_id, exp_amendments_block_a,
+ exp_amendments_block_a_imp)
+ comment_block_b, comment_block_b_imp = CheckComment(
+ issue_block_b.issue_id, exp_amendments_block_b,
+ exp_amendments_block_b_imp)
+
+ exp_issues = [exp_merge_a, exp_merge_b, exp_block_a, exp_block_b]
+ self.assertEqual(len(actual_issues), len(exp_issues))
+ for exp_issue in exp_issues:
+ # All updated issues should have been fetched from DB, skipping cache.
+ # So we expect assume_stale=False was applied to all issues during the
+ # the fetch.
+ exp_issue.assume_stale = False
+ # These derived values get set to the following when an issue goes through
+ # the ApplyFilterRules path. (see filter_helpers._ComputeDerivedFields)
+ exp_issue.derived_status = ''
+ exp_issue.derived_owner_id = 0
+
+ exp_issue.modified_timestamp = self.PAST_TIME
+
+ # Check we successfully updated the issue in our services layer.
+ self.assertEqual(exp_issue, self.services.issue.GetIssue(
+ self.cnxn, exp_issue.issue_id))
+ # Check the issue was successfully returned.
+ self.assertTrue(exp_issue in actual_issues)
+
+ # Check issues enqueued for indexing.
+ reindex_iids = {issue.issue_id for issue in exp_issues}
+ self.services.issue.EnqueueIssuesForIndexing.assert_called_once_with(
+ self.mr.cnxn, reindex_iids, commit=False)
+ self.mr.cnxn.Commit.assert_called_once()
+
+ hostport = 'testing-app.appspot.com'
+ expected_notify_calls = [
+ # Notifications for main changes.
+ mock.call(
+ issue_merge_a.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=comment_merge_a.id,
+ send_email=send_email),
+ mock.call(
+ issue_merge_b.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=comment_merge_b.id,
+ send_email=send_email),
+ mock.call(
+ issue_block_a.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=comment_block_a.id,
+ send_email=send_email),
+ mock.call(
+ issue_block_b.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=comment_block_b.id,
+ send_email=send_email),
+ # Notifications for impacted changes.
+ mock.call(
+ issue_merge_a.issue_id,
+ hostport,
+ self.user_1.user_id,
+ comment_id=comment_merge_a_imp.id,
+ send_email=send_email),
+ mock.call(
+ issue_merge_b.issue_id,
+ hostport,
+ self.user_1.user_id,
+ comment_id=comment_merge_b_imp.id,
+ send_email=send_email),
+ mock.call(
+ issue_block_a.issue_id,
+ hostport,
+ self.user_1.user_id,
+ comment_id=comment_block_a_imp.id,
+ send_email=send_email),
+ mock.call(
+ issue_block_b.issue_id,
+ hostport,
+ self.user_1.user_id,
+ comment_id=comment_block_b_imp.id,
+ send_email=send_email),
+ ]
+ fake_notify.assert_has_calls(expected_notify_calls, any_order=True)
+ fake_bulk_notify.assert_not_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ @mock.patch('time.time')
+ def testModifyIssues(self, fake_time, fake_bulk_notify, fake_notify):
+ fake_time.return_value = self.PAST_TIME
+
+ # A main issue with noop delta.
+ issue_noop = _Issue(789, 1)
+ issue_noop.labels = ['chicken']
+ delta_noop = tracker_pb2.IssueDelta(labels_add=issue_noop.labels)
+
+ exp_issue_noop = copy.deepcopy(issue_noop)
+ exp_amendments_noop = []
+
+ # A main issue with an empty delta and impacts from
+ # issue_shared_a and issue_shared_b.
+ issue_empty = _Issue(789, 2)
+ delta_empty = tracker_pb2.IssueDelta()
+
+ exp_issue_empty = copy.deepcopy(issue_empty)
+ exp_amendments_empty = []
+ exp_amendments_empty_imp = []
+
+ # A main issue with a shared delta_shared.
+ issue_shared_a = _Issue(789, 3)
+ delta_shared = tracker_pb2.IssueDelta(
+ owner_id=self.user_1.user_id, blocked_on_add=[issue_empty.issue_id])
+
+ exp_issue_shared_a = copy.deepcopy(issue_shared_a)
+ exp_issue_shared_a.owner_modified_timestamp = self.PAST_TIME
+ exp_issue_shared_a.owner_id = self.user_1.user_id
+ exp_issue_shared_a.blocked_on_iids.append(issue_empty.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.
+ exp_issue_shared_a.blocked_on_ranks = [0]
+ exp_amendments_shared_a = [
+ tracker_bizobj.MakeOwnerAmendment(
+ delta_shared.owner_id, issue_shared_a.owner_id),
+ tracker_bizobj.MakeBlockedOnAmendment(
+ [(issue_empty.project_name, issue_empty.local_id)], [],
+ default_project_name=issue_shared_a.project_name)]
+ exp_issue_empty.blocking_iids.append(issue_shared_a.issue_id)
+
+ # A main issue with a shared delta_shared.
+ issue_shared_b = _Issue(789, 4)
+
+ exp_issue_shared_b = copy.deepcopy(issue_shared_b)
+ exp_issue_shared_b.owner_modified_timestamp = self.PAST_TIME
+ exp_issue_shared_b.owner_id = delta_shared.owner_id
+ exp_issue_shared_b.blocked_on_iids.append(issue_empty.issue_id)
+ exp_issue_shared_b.blocked_on_ranks = [0]
+
+ exp_amendments_shared_b = [
+ tracker_bizobj.MakeOwnerAmendment(
+ delta_shared.owner_id, issue_shared_b.owner_id),
+ tracker_bizobj.MakeBlockedOnAmendment(
+ [(issue_empty.project_name, issue_empty.local_id)], [],
+ default_project_name=issue_shared_b.project_name)]
+ exp_issue_empty.blocking_iids.append(issue_shared_b.issue_id)
+
+ added_refs = [(issue_shared_b.project_name, issue_shared_b.local_id),
+ (issue_shared_a.project_name, issue_shared_a.local_id)]
+ exp_amendments_empty_imp.append(tracker_bizobj.MakeBlockingAmendment(
+ added_refs, [], default_project_name=issue_empty.project_name))
+
+ # Issues impacted by issue_unique.
+ imp_issue_a = _Issue(789, 11)
+ imp_issue_a.owner_id = self.user_1.user_id
+ imp_issue_b = _Issue(789, 12)
+
+ exp_imp_issue_a = copy.deepcopy(imp_issue_a)
+ exp_imp_issue_b = copy.deepcopy(imp_issue_b)
+
+ # A main issue with a unique delta and impact on imp_issue_{a|b}.
+ issue_unique = _Issue(789, 5)
+ issue_unique.merged_into = imp_issue_b.issue_id
+ delta_unique = tracker_pb2.IssueDelta(
+ merged_into=imp_issue_a.issue_id, status='Duplicate')
+
+ exp_issue_unique = copy.deepcopy(issue_unique)
+ exp_issue_unique.merged_into = imp_issue_a.issue_id
+ exp_issue_unique.status = 'Duplicate'
+ exp_issue_unique.status_modified_timestamp = self.PAST_TIME
+ exp_amendments_unique = [
+ tracker_bizobj.MakeStatusAmendment('Duplicate', ''),
+ tracker_bizobj.MakeMergedIntoAmendment(
+ [(imp_issue_a.project_name, imp_issue_a.local_id)],
+ [(imp_issue_b.project_name, imp_issue_b.local_id)],
+ default_project_name=issue_unique.project_name)
+ ]
+
+ # We star issue_5 and expect this star to be merged into imp_issue.
+ exp_imp_starrer = 444
+ self.services.issue_star.SetStar(
+ self.cnxn, self.services, None, issue_unique.issue_id,
+ exp_imp_starrer, True)
+ exp_imp_issue_a.star_count = 1
+
+ # Add a FilterRule for star_count to check filter rules are applied.
+ starred_label = 'starry-night'
+ self.services.features.TestAddFilterRule(
+ 789, 'stars=1', add_labels=[starred_label])
+ exp_imp_issue_a.derived_labels.append(starred_label)
+
+ # Setting status away from a MERGED type auto-removes any merged_into.
+ issue_unmerged = _Issue(789, 6)
+ issue_unmerged.merged_into_external = 'b/123'
+ issue_unmerged.status = 'Duplicate'
+ delta_unmerged = tracker_pb2.IssueDelta(status='Available')
+
+ exp_issue_unmerged = copy.deepcopy(issue_unmerged)
+ exp_issue_unmerged.status = 'Available'
+ exp_issue_unmerged.merged_into_external = ''
+ exp_issue_unmerged.merged_into = 0
+ exp_issue_unmerged.status_modified_timestamp = self.PAST_TIME
+ exp_amendments_unmerged = [
+ tracker_bizobj.MakeStatusAmendment('Available', 'Duplicate'),
+ tracker_bizobj.MakeMergedIntoAmendment(
+ [], [tracker_pb2.DanglingIssueRef(ext_issue_identifier='b/123')])
+ ]
+
+ self.services.issue.TestAddIssue(imp_issue_a)
+ self.services.issue.TestAddIssue(imp_issue_b)
+ self.services.issue.TestAddIssue(issue_noop)
+ self.services.issue.TestAddIssue(issue_empty)
+ self.services.issue.TestAddIssue(issue_shared_a)
+ self.services.issue.TestAddIssue(issue_shared_b)
+ self.services.issue.TestAddIssue(issue_unique)
+ self.services.issue.TestAddIssue(issue_unmerged)
+
+ issue_delta_pairs = [
+ (issue_noop.issue_id, delta_noop), (issue_empty.issue_id, delta_empty),
+ (issue_shared_a.issue_id, delta_shared),
+ (issue_shared_b.issue_id, delta_shared),
+ (issue_unique.issue_id, delta_unique),
+ (issue_unmerged.issue_id, delta_unmerged)
+ ]
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ content = 'Je suis un ananas.'
+ self.SignIn(self.user_1.user_id)
+ send_email = True
+ with self.work_env as we:
+ actual_issues = we.ModifyIssues(
+ issue_delta_pairs,
+ False,
+ comment_content=content,
+ send_email=send_email)
+
+ # Check comments correct.
+ # We expect all issues to have a description comment and the comment(s)
+ # added from the ModifyIssues() changes.
+ (_desc, comment_noop
+ ) = self.services.issue.comments_by_iid[issue_noop.issue_id]
+ self.assertEqual(comment_noop.amendments, exp_amendments_noop)
+ self.assertEqual(comment_noop.content, content)
+
+ # Modified issues that are also impacted, get two comments:
+ # One with the comment content and, direct issue changes defined in a
+ # paired delta.
+ # One with the impacted changes with no comment content.
+ (_desc, comment_empty, comment_empty_imp
+ ) = self.services.issue.comments_by_iid[issue_empty.issue_id]
+ self.assertEqual(comment_empty.amendments, exp_amendments_empty)
+ self.assertEqual(comment_empty.content, content)
+ self.assertEqual(comment_empty_imp.amendments, exp_amendments_empty_imp)
+ self.assertEqual(comment_empty_imp.content, '')
+
+ [_desc, shared_a_comment] = self.services.issue.comments_by_iid[
+ issue_shared_a.issue_id]
+ self.assertEqual(shared_a_comment.amendments, exp_amendments_shared_a)
+ self.assertEqual(shared_a_comment.content, content)
+
+ (_desc, shared_b_comment) = self.services.issue.comments_by_iid[
+ issue_shared_b.issue_id]
+ self.assertEqual(shared_b_comment.amendments, exp_amendments_shared_b)
+ self.assertEqual(shared_b_comment.content, content)
+
+ (_desc, unique_comment) = self.services.issue.comments_by_iid[
+ issue_unique.issue_id]
+ self.assertEqual(unique_comment.amendments, exp_amendments_unique)
+ self.assertEqual(unique_comment.content, content)
+
+ (_des, unmerged_comment
+ ) = self.services.issue.comments_by_iid[issue_unmerged.issue_id]
+ self.assertEqual(unmerged_comment.amendments, exp_amendments_unmerged)
+ self.assertEqual(unmerged_comment.content, content)
+
+ # imp_issue_{a|b} were only an impacted issue and never main issues with
+ # IssueDelta changes. Only one comment with impacted changes should
+ # have been added.
+ (_desc,
+ imp_a_comment) = self.services.issue.comments_by_iid[imp_issue_a.issue_id]
+ self.assertEqual(imp_a_comment.amendments, [])
+ self.assertEqual(
+ imp_a_comment.content,
+ 'Issue %s has been merged into this issue.\n' % issue_unique.local_id)
+ (_desc,
+ imp_b_comment) = self.services.issue.comments_by_iid[imp_issue_b.issue_id]
+ self.assertEqual(imp_b_comment.amendments, [])
+ self.assertEqual(
+ imp_b_comment.content,
+ 'Issue %s has been un-merged from this issue.\n' %
+ issue_unique.local_id)
+
+ # Check stars correct.
+ self.assertEqual(
+ [exp_imp_starrer],
+ self.services.issue_star.stars_by_item_id[imp_issue_a.issue_id])
+
+ # Check issues correct.
+ expected_issues = [
+ exp_issue_noop, exp_issue_empty, exp_issue_shared_a, exp_issue_shared_b,
+ exp_issue_unique, exp_imp_issue_a, exp_imp_issue_b, exp_issue_unmerged
+ ]
+ # Check we successfully updated these in our services layer.
+ for exp_issue in expected_issues:
+ # All updated issues should have been fetched from DB, skipping cache.
+ # So we expect assume_stale=False was applied to all issues during the
+ # the fetch.
+ exp_issue.assume_stale = False
+ # These derived values get set to the following when an issue goes through
+ # the ApplyFilterRules path. (see filter_helpers._ComputeDerivedFields)
+ # issue_noop had no changes so filter rules were never applied to it.
+ if exp_issue != exp_issue_noop:
+ exp_issue.derived_status = ''
+ exp_issue.derived_owner_id = 0
+
+ exp_issue.modified_timestamp = self.PAST_TIME
+
+ self.assertEqual(
+ exp_issue, self.services.issue.GetIssue(self.cnxn, exp_issue.issue_id))
+ # Check the expected issues were successfully returned.
+ exp_actual_issues = [
+ exp_issue_noop, exp_issue_empty, exp_issue_shared_a, exp_issue_shared_b,
+ exp_issue_unique, exp_issue_unmerged
+ ]
+ self.assertEqual(len(exp_actual_issues), len(actual_issues))
+ for issue in actual_issues:
+ self.assertTrue(issue in exp_actual_issues)
+
+ # Check notifications sent.
+ hostport = 'testing-app.appspot.com'
+ expected_notify_calls = [
+ # Notified as a main issue update.
+ mock.call(
+ issue_noop.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=comment_noop.id,
+ send_email=send_email),
+ # Notified as a main issue update.
+ mock.call(
+ issue_empty.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=comment_empty.id,
+ send_email=send_email),
+ # Notified as a main issue update.
+ mock.call(
+ issue_unique.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=unique_comment.id,
+ send_email=send_email),
+ # Notified as a main issue update.
+ mock.call(
+ issue_unmerged.issue_id,
+ hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=unmerged_comment.id,
+ send_email=send_email),
+ # Notified as an impacted issue update.
+ mock.call(
+ imp_issue_b.issue_id,
+ hostport,
+ self.user_1.user_id,
+ comment_id=imp_b_comment.id,
+ send_email=send_email),
+ # Notified as an impacted issue update.
+ mock.call(
+ issue_empty.issue_id,
+ hostport,
+ self.user_1.user_id,
+ comment_id=comment_empty_imp.id,
+ send_email=send_email),
+ # Notified as an impacted issue update.
+ mock.call(
+ imp_issue_a.issue_id,
+ hostport,
+ self.user_1.user_id,
+ comment_id=imp_a_comment.id,
+ send_email=send_email)
+ ]
+ fake_notify.assert_has_calls(expected_notify_calls)
+ old_owner_ids = []
+ shared_amendments = exp_amendments_shared_a + exp_amendments_shared_b
+ users_by_id = {0: mock.ANY, 111: mock.ANY}
+ fake_bulk_notify.assert_called_once_with(
+ {issue_shared_a.issue_id, issue_shared_b.issue_id}, hostport,
+ old_owner_ids, content, self.user_1.user_id, shared_amendments,
+ send_email, users_by_id)
+
+ # Check issues enqueued for indexing.
+ reindex_iids = {issue.issue_id for issue in expected_issues}
+ self.services.issue.EnqueueIssuesForIndexing.assert_called_once_with(
+ self.mr.cnxn, reindex_iids, commit=False)
+ self.mr.cnxn.Commit.assert_called_once()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ @mock.patch('time.time')
+ def testModifyIssues_ComponentModified(
+ self, fake_time, fake_bulk_notify, fake_notify):
+ fake_time.return_value = self.PAST_TIME
+
+ issue = _Issue(789, 1)
+ issue.component_ids = [self.component_id_1]
+ delta = tracker_pb2.IssueDelta(
+ comp_ids_add=[self.component_id_2],
+ comp_ids_remove=[self.component_id_1])
+
+ exp_issue = copy.deepcopy(issue)
+
+ self.services.issue.TestAddIssue(issue)
+
+ issue_delta_pairs = [(issue.issue_id, delta)]
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ content = 'Modifying component'
+ self.SignIn(self.user_1.user_id)
+ send_email = True
+
+ with self.work_env as we:
+ we.ModifyIssues(
+ issue_delta_pairs,
+ False,
+ comment_content=content,
+ send_email=send_email)
+
+ exp_issue.modified_timestamp = self.PAST_TIME
+ exp_issue.component_modified_timestamp = self.PAST_TIME
+ exp_issue.component_ids = [self.component_id_2]
+
+ exp_issue.derived_status = ''
+ exp_issue.derived_owner_id = 0
+ exp_issue.assume_stale = False
+
+ self.assertEqual(
+ exp_issue, self.services.issue.GetIssue(self.cnxn, exp_issue.issue_id))
+
+ fake_bulk_notify.assert_not_called()
+ fake_notify.assert_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ @mock.patch('time.time')
+ def testModifyIssues_StatusModified(
+ self, fake_time, fake_bulk_notify, fake_notify):
+ fake_time.return_value = self.PAST_TIME
+
+ issue = _Issue(789, 1)
+ issue.status = 'New'
+ delta = tracker_pb2.IssueDelta(status='Fixed')
+
+ exp_issue = copy.deepcopy(issue)
+
+ self.services.issue.TestAddIssue(issue)
+
+ issue_delta_pairs = [(issue.issue_id, delta)]
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ content = 'Modifying status'
+ self.SignIn(self.user_1.user_id)
+ send_email = True
+
+ with self.work_env as we:
+ we.ModifyIssues(
+ issue_delta_pairs,
+ False,
+ comment_content=content,
+ send_email=send_email)
+
+ exp_issue.modified_timestamp = self.PAST_TIME
+ exp_issue.status_modified_timestamp = self.PAST_TIME
+ exp_issue.closed_timestamp = self.PAST_TIME
+ exp_issue.status = 'Fixed'
+
+ exp_issue.derived_status = ''
+ exp_issue.derived_owner_id = 0
+ exp_issue.assume_stale = False
+
+ self.assertEqual(
+ exp_issue, self.services.issue.GetIssue(self.cnxn, exp_issue.issue_id))
+
+ fake_bulk_notify.assert_not_called()
+ fake_notify.assert_called()
+
+ # We must redirect the testing environment's default domain to a
+ # non-appspot.com one, in order for the per-project branded domains to get
+ # used. See framework_helpers.GetNeededDomain().
+ @mock.patch(
+ 'settings.preferred_domains', {'testing-app.appspot.com': 'example.com'})
+ @mock.patch(
+ 'settings.branded_domains', {
+ 'proj-783': '783.com', 'proj-782': '782.com', 'proj-781': '781.com'})
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ @mock.patch('time.time')
+ def testModifyIssues_MultiProjectChanges(
+ self, fake_time, fake_bulk_notify, fake_notify):
+ fake_time.return_value = self.PAST_TIME
+ self.services.project.TestAddProject(
+ 'proj-783', project_id=783, committer_ids=[self.user_1.user_id])
+ self.services.project.TestAddProject(
+ 'proj-782', project_id=782, committer_ids=[self.user_1.user_id])
+ self.services.project.TestAddProject(
+ 'proj-781', project_id=781, committer_ids=[self.user_1.user_id])
+ delta = tracker_pb2.IssueDelta(cc_ids_add=[self.user_2.user_id])
+
+ def setUpIssue(pid, local_id):
+ issue = _Issue(pid, local_id)
+ exp_amendments = [tracker_bizobj.MakeCcAmendment(delta.cc_ids_add, [])]
+ exp_issue = copy.deepcopy(issue)
+ exp_issue.cc_ids.extend(delta.cc_ids_add)
+ exp_issue.modified_timestamp = self.PAST_TIME
+ return issue, exp_amendments, exp_issue
+
+ # We expect fake_bulk_notify to send these issues' notifications.
+ issue_p1a, exp_amendments_p1a, exp_p1a = setUpIssue(781, 1)
+ issue_p1b, exp_amendments_p1b, exp_p1b = setUpIssue(781, 2)
+
+ # We expect fake_notify to send this issue's notification.
+ issue_p2, exp_amendments_p2, exp_p2 = setUpIssue(782, 1)
+
+ # We expect fake_bulk_notify to send these issues' notifications.
+ issue_p3a, exp_amendments_p3a, exp_p3a = setUpIssue(783, 1)
+ issue_p3b, exp_amendments_p3b, exp_p3b = setUpIssue(783, 2)
+
+ self.services.issue.TestAddIssue(issue_p1a)
+ self.services.issue.TestAddIssue(issue_p1b)
+ self.services.issue.TestAddIssue(issue_p2)
+ self.services.issue.TestAddIssue(issue_p3a)
+ self.services.issue.TestAddIssue(issue_p3b)
+
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ issue_delta_pairs = [(issue_p1a.issue_id, delta),
+ (issue_p1b.issue_id, delta),
+ (issue_p2.issue_id, delta),
+ (issue_p3a.issue_id, delta),
+ (issue_p3b.issue_id, delta)]
+ self.SignIn(self.user_1.user_id)
+ content = None
+ send_email = True
+ with self.work_env as we:
+ actual_issues = we.ModifyIssues(
+ issue_delta_pairs, False, send_email=send_email)
+
+ # Check comments.
+ # We expect all issues to have a description comment and the comment(s)
+ # added from the ModifyIssues() changes.
+ def CheckComment(issue_id, exp_amendments):
+ (_desc, comment) = self.services.issue.comments_by_iid[issue_id]
+ self.assertEqual(comment.amendments, exp_amendments)
+ self.assertEqual(comment.content, content)
+ return comment
+
+ _comment_p1a = CheckComment(issue_p1a.issue_id, exp_amendments_p1a)
+ _comment_p1b = CheckComment(issue_p1b.issue_id, exp_amendments_p1b)
+ comment_p2 = CheckComment(issue_p2.issue_id, exp_amendments_p2)
+ _comment_p3a = CheckComment(issue_p3a.issue_id, exp_amendments_p3a)
+ _comment_p3b = CheckComment(issue_p3b.issue_id, exp_amendments_p3b)
+
+ # Check issues.
+ exp_issues = [exp_p1a, exp_p1b, exp_p2, exp_p3a, exp_p3b]
+ for exp_issue in exp_issues:
+ # All updated issues should have been fetched from DB, skipping cache.
+ # So we expect assume_stale=False was applied to all issues during the
+ # the fetch.
+ exp_issue.assume_stale = False
+ # These derived values get set to the following when an issue goes through
+ # the ApplyFilterRules path. (see filter_helpers._ComputeDerivedFields)
+ exp_issue.derived_status = ''
+ exp_issue.derived_owner_id = 0
+ # Check we successfully updated these issues in our services layer.
+ self.assertEqual(exp_issue, self.services.issue.GetIssue(
+ self.cnxn, exp_issue.issue_id))
+ # Check the expected issues were successfully returned.
+ self.assertTrue(exp_issue in actual_issues)
+
+ # Check issues enqueued for indexing.
+ reindex_iids = {issue.issue_id for issue in exp_issues}
+ self.services.issue.EnqueueIssuesForIndexing.assert_called_once_with(
+ self.mr.cnxn, reindex_iids, commit=False)
+ self.mr.cnxn.Commit.assert_called_once()
+
+ # Check notifications.
+ p2_hostport = '782.com'
+ fake_notify.assert_called_once_with(
+ issue_p2.issue_id,
+ p2_hostport,
+ self.user_1.user_id,
+ old_owner_id=None,
+ comment_id=comment_p2.id,
+ send_email=send_email)
+
+ p1_hostport = '781.com'
+ p1_amendments = exp_amendments_p1a + exp_amendments_p1b
+ p3_hostport = '783.com'
+ p3_amendments = exp_amendments_p3a + exp_amendments_p3b
+ users_by_id = {222: mock.ANY}
+ old_owners = []
+ expected_bulk_calls = [
+ mock.call({issue_p3a.issue_id, issue_p3b.issue_id}, p3_hostport,
+ old_owners, content, self.user_1.user_id, p3_amendments,
+ send_email, users_by_id),
+ mock.call({issue_p1a.issue_id, issue_p1b.issue_id}, p1_hostport,
+ old_owners, content, self.user_1.user_id, p1_amendments,
+ send_email, users_by_id)]
+ fake_bulk_notify.assert_has_calls(expected_bulk_calls, any_order=True)
+
+ def testModifyIssues_PermDenied(self):
+ """Test that AssertUsercanModifyIssues is called."""
+ issue = _Issue(789, 1)
+ delta = tracker_pb2.IssueDelta(labels_add=['some-label'])
+ non_member = self.services.user.TestAddUser('non_member@example.com', 666)
+ self.services.issue.TestAddIssue(issue)
+ self.SignIn(non_member.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.ModifyIssues(
+ [(issue.issue_id, delta)], False, comment_content='bad chicken')
+
+ # Detailed change validation testing happens in tracker_helpers_test.
+ def testModifyIssues_InvalidChange(self):
+ """Test that we check issue change validity."""
+ non_member = self.services.user.TestAddUser('non_member@example.com', 666)
+ issue = _Issue(789, 1)
+ delta = tracker_pb2.IssueDelta(owner_id=non_member.user_id)
+ self.services.issue.TestAddIssue(issue)
+ self.SignIn(self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.ModifyIssues(
+ [(issue.issue_id, delta)], False, comment_content='bad chicken')
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ def testModifyIssues_Noop(self, fake_bulk_notify, fake_notify):
+ issue_empty = _Issue(789, 1)
+ delta_empty = tracker_pb2.IssueDelta()
+
+ issue_noop = _Issue(789, 2)
+ issue_noop.owner_id = self.user_2.user_id
+ delta_noop = tracker_pb2.IssueDelta(owner_id=issue_noop.owner_id)
+
+ delta_noop_shared = tracker_pb2.IssueDelta(owner_id=issue_noop.owner_id)
+ issue_noop_shared_a = _Issue(789, 3)
+ issue_noop_shared_a.owner_id = delta_noop_shared.owner_id
+ issue_noop_shared_b = _Issue(789, 4)
+ issue_noop_shared_b.owner_id = delta_noop_shared.owner_id
+
+ self.services.issue.TestAddIssue(issue_empty)
+ self.services.issue.TestAddIssue(issue_noop)
+ self.services.issue.TestAddIssue(issue_noop_shared_a)
+ self.services.issue.TestAddIssue(issue_noop_shared_b)
+
+ exp_issues = [
+ copy.deepcopy(issue_empty),
+ copy.deepcopy(issue_noop),
+ copy.deepcopy(issue_noop_shared_a),
+ copy.deepcopy(issue_noop_shared_b)
+ ]
+
+ issue_delta_pairs = [(issue_empty.issue_id, delta_empty),
+ (issue_noop.issue_id, delta_noop),
+ (issue_noop_shared_a.issue_id, delta_noop_shared),
+ (issue_noop_shared_b.issue_id, delta_noop_shared)]
+
+
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.UpdateIssue = mock.Mock()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate = mock.Mock()
+ self.services.issue.CreateIssueComment = mock.Mock()
+ self.services.project.UpdateProject = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ self.SignIn(self.user_1.user_id)
+ with self.work_env as we:
+ issues = we.ModifyIssues(issue_delta_pairs, False, send_email=True)
+
+ for exp_issue in exp_issues:
+ exp_issue.assume_stale = False
+ # Check issues remained the same with no changes.
+ self.assertEqual(
+ exp_issue,
+ self.services.issue.GetIssue(self.cnxn, exp_issue.issue_id))
+
+ self.assertFalse(issues)
+ self.services.issue.UpdateIssue.assert_not_called()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate.assert_not_called()
+ self.services.issue.CreateIssueComment.assert_not_called()
+ self.services.project.UpdateProject.assert_not_called()
+ self.services.issue.EnqueueIssuesForIndexing.assert_not_called()
+ fake_bulk_notify.assert_not_called()
+ fake_notify.assert_not_called()
+ self.mr.cnxn.Commit.assert_not_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ @mock.patch('time.time')
+ def testModifyIssues_CommentWithNoChanges(
+ self, fake_time, fake_bulk_notify, fake_notify):
+ fake_time.return_value = self.PAST_TIME
+
+ issue = _Issue(789, 1)
+ delta_empty = tracker_pb2.IssueDelta()
+
+ exp_issue = copy.deepcopy(issue)
+ exp_issue.modified_timestamp = self.PAST_TIME
+ exp_issue.assume_stale = False
+
+ self.services.issue.TestAddIssue(issue)
+
+ issue_delta_pairs = [(issue.issue_id, delta_empty)]
+
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.UpdateIssue = mock.Mock()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate = mock.Mock()
+ self.services.issue.CreateIssueComment = mock.Mock()
+ self.services.project.UpdateProject = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ self.SignIn(self.user_1.user_id)
+
+ with self.work_env as we:
+ issues = we.ModifyIssues(
+ issue_delta_pairs, False, comment_content='invisible chickens')
+
+ self.assertEqual(len(issues), 1)
+ self.assertEqual(exp_issue, issues[0])
+ self.assertEqual(
+ exp_issue, self.services.issue.GetIssue(self.cnxn, exp_issue.issue_id))
+
+ self.services.issue.UpdateIssue.assert_not_called()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate.assert_not_called()
+ self.services.issue.CreateIssueComment.assert_called()
+ self.services.project.UpdateProject.assert_not_called()
+ self.services.issue.EnqueueIssuesForIndexing.assert_called()
+
+ fake_bulk_notify.assert_not_called()
+ fake_notify.assert_called()
+ self.mr.cnxn.Commit.assert_called()
+ # The closed_timestamp has ben reset to its default value of 0.
+ self.assertEqual(
+ 0,
+ self.services.issue.GetIssue(self.cnxn,
+ exp_issue.issue_id).closed_timestamp)
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ @mock.patch('time.time')
+ def testModifyIssues_AttachmentsWithNoChanges(
+ self, fake_time, fake_bulk_notify, fake_notify):
+
+ fake_time.return_value = self.PAST_TIME
+
+ issue = _Issue(789, 1)
+ delta_empty = tracker_pb2.IssueDelta()
+
+ exp_issue = copy.deepcopy(issue)
+ exp_issue.modified_timestamp = self.PAST_TIME
+ exp_issue.assume_stale = False
+
+ self.services.issue.TestAddIssue(issue)
+
+ issue_delta_pairs = [(issue.issue_id, delta_empty)]
+
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.UpdateIssue = mock.Mock()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate = mock.Mock()
+ self.services.issue.CreateIssueComment = mock.Mock()
+ self.services.project.UpdateProject = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ self.SignIn(self.user_1.user_id)
+
+ upload = framework_helpers.AttachmentUpload(
+ 'BEAR-necessities', 'Forget about your worries and your strife',
+ 'text/plain')
+
+ with self.work_env as we:
+ issues = we.ModifyIssues(issue_delta_pairs, attachment_uploads=[upload])
+
+ self.assertEqual(len(issues), 1)
+ self.assertEqual(exp_issue, issues[0])
+ self.assertEqual(
+ exp_issue, self.services.issue.GetIssue(self.cnxn, exp_issue.issue_id))
+
+ self.services.issue.UpdateIssue.assert_not_called()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate.assert_not_called()
+ self.services.issue.CreateIssueComment.assert_called()
+ self.services.project.UpdateProject.assert_called()
+ self.services.issue.EnqueueIssuesForIndexing.assert_called()
+
+ fake_bulk_notify.assert_not_called()
+ fake_notify.assert_called()
+ self.mr.cnxn.Commit.assert_called()
+
+ @mock.patch(
+ 'features.send_notifications.PrepareAndSendIssueChangeNotification')
+ @mock.patch('features.send_notifications.SendIssueBulkChangeNotification')
+ def testModifyIssues_Empty(self, fake_bulk_notify, fake_notify):
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.issue.UpdateIssue = mock.Mock()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate = mock.Mock()
+ self.services.issue.CreateIssueComment = mock.Mock()
+ self.services.issue.EnqueueIssuesForIndexing = mock.Mock()
+ with self.work_env as we:
+ issues = we.ModifyIssues([], False, comment_content='invisible chickens')
+
+ self.assertFalse(issues)
+ self.services.issue.UpdateIssue.assert_not_called()
+ self.services.issue_star.SetStarsBatch_SkipIssueUpdate.assert_not_called()
+ self.services.issue.CreateIssueComment.assert_not_called()
+ self.services.issue.EnqueueIssuesForIndexing.assert_not_called()
+ fake_bulk_notify.assert_not_called()
+ fake_notify.assert_not_called()
+ self.mr.cnxn.Commit.assert_not_called()
+
+
+ def testModifyIssuesBulkNotifyForDelta(self):
+ # Integrate tested in ModifyIssues tests as the main concern is
+ # if BulkNotify and Notify work correctly together in the ModifyIssues
+ # context.
+ pass
+
+ def testModifyIssuesNotifyForDelta(self):
+ # Integrate tested in ModifyIssues tests as the main concern is
+ # if BulkNotify and Notify work correctly together in the ModifyIssues
+ # context.
+ pass
+
+ def testDeleteIssue(self):
+ """We can mark and unmark an issue as deleted."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ with self.work_env as we:
+ _actual = we.DeleteIssue(issue, True)
+ self.assertTrue(issue.deleted)
+ with self.work_env as we:
+ _actual = we.DeleteIssue(issue, False)
+ self.assertFalse(issue.deleted)
+
+ def testFlagIssue_Normal(self):
+ """Users can mark and unmark an issue as spam."""
+ self.services.user.TestAddUser('user222@example.com', 222)
+ self.SignIn(user_id=222)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ with self.work_env as we:
+ we.FlagIssues([issue], True)
+ self.assertEqual(
+ [222], self.services.spam.reports_by_issue_id[78901])
+ self.assertNotIn(
+ 222, self.services.spam.manual_verdicts_by_issue_id[78901])
+ with self.work_env as we:
+ we.FlagIssues([issue], False)
+ self.assertEqual(
+ [], self.services.spam.reports_by_issue_id[78901])
+ self.assertNotIn(
+ 222, self.services.spam.manual_verdicts_by_issue_id[78901])
+
+ def testFlagIssue_AutoVerdict(self):
+ """Admins can mark and unmark an issue as spam and it counts as verdict."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ with self.work_env as we:
+ we.FlagIssues([issue], True)
+ self.assertEqual(
+ [444], self.services.spam.reports_by_issue_id[78901])
+ self.assertTrue(self.services.spam.manual_verdicts_by_issue_id[78901][444])
+ with self.work_env as we:
+ we.FlagIssues([issue], False)
+ self.assertEqual(
+ [], self.services.spam.reports_by_issue_id[78901])
+ self.assertFalse(
+ self.services.spam.manual_verdicts_by_issue_id[78901][444])
+
+ def testFlagIssue_NotAllowed(self):
+ """Anons can't mark issues as spam."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.FlagIssues([issue], True)
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.FlagIssues([issue], False)
+
+ def testLookupIssuesFlaggers_Normal(self):
+ issue_1 = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue_1)
+ comment_1_1 = tracker_pb2.IssueComment(
+ project_id=789, content='lorem ipsum', user_id=111,
+ issue_id=issue_1.issue_id)
+ comment_1_2 = tracker_pb2.IssueComment(
+ project_id=789, content='dolor sit amet', user_id=111,
+ issue_id=issue_1.issue_id)
+ self.services.issue.TestAddComment(comment_1_1, 1)
+ self.services.issue.TestAddComment(comment_1_2, 1)
+
+ issue_2 = fake.MakeTestIssue(789, 2, 'sum', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue_2)
+ comment_2_1 = tracker_pb2.IssueComment(
+ project_id=789, content='lorem ipsum', user_id=111,
+ issue_id=issue_2.issue_id)
+ self.services.issue.TestAddComment(comment_2_1, 2)
+
+
+ self.SignIn(user_id=222)
+ with self.work_env as we:
+ we.FlagIssues([issue_1], True)
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ we.FlagComment(issue_1, comment_1_2, True)
+ we.FlagComment(issue_2, comment_2_1, True)
+
+ reporters = we.LookupIssuesFlaggers([issue_1, issue_2])
+ self.assertEqual({
+ issue_1.issue_id: ([222], {comment_1_2.id: [111]}),
+ issue_2.issue_id: ([], {comment_2_1.id: [111]}),
+ }, reporters)
+
+ def testLookupIssueFlaggers_Normal(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment_1 = tracker_pb2.IssueComment(
+ project_id=789, content='lorem ipsum', user_id=111,
+ issue_id=issue.issue_id)
+ comment_2 = tracker_pb2.IssueComment(
+ project_id=789, content='dolor sit amet', user_id=111,
+ issue_id=issue.issue_id)
+ self.services.issue.TestAddComment(comment_1, 1)
+ self.services.issue.TestAddComment(comment_2, 2)
+
+ self.SignIn(user_id=222)
+ with self.work_env as we:
+ we.FlagIssues([issue], True)
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ we.FlagComment(issue, comment_2, True)
+ issue_reporters, comment_reporters = we.LookupIssueFlaggers(issue)
+ self.assertEqual([222], issue_reporters)
+ self.assertEqual({comment_2.id: [111]}, comment_reporters)
+
+ def testGetIssuePositionInHotlist(self):
+ issue1 = fake.MakeTestIssue(
+ 789, 1, 'sum1', 'New', self.user_1.user_id, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ issue2 = fake.MakeTestIssue(
+ 789, 2, 'sum1', 'New', self.user_2.user_id, issue_id=78902)
+ self.services.issue.TestAddIssue(issue2)
+ issue3 = fake.MakeTestIssue(
+ 789, 3, 'sum1', 'New', self.user_3.user_id, issue_id=78903)
+ self.services.issue.TestAddIssue(issue3)
+
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[self.user_1.user_id], editor_ids=[])
+ self.AddIssueToHotlist(hotlist.hotlist_id, issue_id=issue2.issue_id)
+ self.AddIssueToHotlist(hotlist.hotlist_id, issue_id=issue1.issue_id)
+ self.AddIssueToHotlist(hotlist.hotlist_id, issue_id=issue3.issue_id)
+
+ with self.work_env as we:
+ prev_iid, cur_index, next_iid, total_count = we.GetIssuePositionInHotlist(
+ issue1, hotlist, 1, 'rank', '')
+
+ self.assertEqual(prev_iid, issue2.issue_id)
+ self.assertEqual(cur_index, 1)
+ self.assertEqual(next_iid, issue3.issue_id)
+ self.assertEqual(total_count, 3)
+
+ def testRerankBlockedOnIssues_SplitBelow(self):
+ parent_issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, project_name='proj', issue_id=1001)
+ self.services.issue.TestAddIssue(parent_issue)
+
+ issues = []
+ for idx in range(2, 6):
+ issues.append(fake.MakeTestIssue(
+ 789, idx, 'sum', 'New', 111, project_name='proj', issue_id=1000+idx))
+ self.services.issue.TestAddIssue(issues[-1])
+ parent_issue.blocked_on_iids.append(issues[-1].issue_id)
+ next_rank = sys.maxint
+ if parent_issue.blocked_on_ranks:
+ next_rank = parent_issue.blocked_on_ranks[-1] - 1
+ parent_issue.blocked_on_ranks.append(next_rank)
+
+ self.SignIn()
+ with self.work_env as we:
+ we.RerankBlockedOnIssues(parent_issue, 1002, 1004, False)
+ new_parent_issue = we.GetIssue(1001)
+
+ self.assertEqual([1003, 1004, 1002, 1005], new_parent_issue.blocked_on_iids)
+
+ def testRerankBlockedOnIssues_SplitAbove(self):
+ parent_issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, project_name='proj', issue_id=1001)
+ self.services.issue.TestAddIssue(parent_issue)
+
+ issues = []
+ for idx in range(2, 6):
+ issues.append(fake.MakeTestIssue(
+ 789, idx, 'sum', 'New', 111, project_name='proj', issue_id=1000+idx))
+ self.services.issue.TestAddIssue(issues[-1])
+ parent_issue.blocked_on_iids.append(issues[-1].issue_id)
+ next_rank = sys.maxint
+ if parent_issue.blocked_on_ranks:
+ next_rank = parent_issue.blocked_on_ranks[-1] - 1
+ parent_issue.blocked_on_ranks.append(next_rank)
+
+ self.SignIn()
+ with self.work_env as we:
+ we.RerankBlockedOnIssues(parent_issue, 1002, 1004, True)
+ new_parent_issue = we.GetIssue(1001)
+
+ self.assertEqual([1003, 1002, 1004, 1005], new_parent_issue.blocked_on_iids)
+
+ @mock.patch('tracker.rerank_helpers.MAX_RANKING', 1)
+ def testRerankBlockedOnIssues_NoRoom(self):
+ parent_issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, project_name='proj', issue_id=1001)
+ parent_issue.blocked_on_ranks = [1, 0, 0]
+ self.services.issue.TestAddIssue(parent_issue)
+
+ issues = []
+ for idx in range(2, 5):
+ issues.append(fake.MakeTestIssue(
+ 789, idx, 'sum', 'New', 111, project_name='proj', issue_id=1000+idx))
+ self.services.issue.TestAddIssue(issues[-1])
+ parent_issue.blocked_on_iids.append(issues[-1].issue_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ we.RerankBlockedOnIssues(parent_issue, 1003, 1004, True)
+ new_parent_issue = we.GetIssue(1001)
+
+ self.assertEqual([1002, 1003, 1004], new_parent_issue.blocked_on_iids)
+
+ def testRerankBlockedOnIssues_CantEditIssue(self):
+ parent_issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 555, project_name='proj', issue_id=1001)
+ parent_issue.labels = ['Restrict-EditIssue-Foo']
+ self.services.issue.TestAddIssue(parent_issue)
+
+ self.SignIn()
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.RerankBlockedOnIssues(parent_issue, 1003, 1002, True)
+
+ def testRerankBlockedOnIssues_MovedNotOnBlockedOn(self):
+ parent_issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, project_name='proj', issue_id=1001)
+ self.services.issue.TestAddIssue(parent_issue)
+
+ self.SignIn()
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.RerankBlockedOnIssues(parent_issue, 1003, 1002, True)
+
+ def testRerankBlockedOnIssues_TargetNotOnBlockedOn(self):
+ moved = fake.MakeTestIssue(
+ 789, 2, 'sum', 'New', 111, project_name='proj', issue_id=1002)
+ self.services.issue.TestAddIssue(moved)
+ parent_issue = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, project_name='proj', issue_id=1001)
+ parent_issue.blocked_on_iids = [1002]
+ parent_issue.blocked_on_ranks = [1]
+ self.services.issue.TestAddIssue(parent_issue)
+
+ self.SignIn()
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.RerankBlockedOnIssues(parent_issue, 1002, 1003, True)
+
+ # FUTURE: GetIssuePermissionsForUser()
+
+ # FUTURE: CreateComment()
+
+ def testListIssueComments_Normal(self):
+ """We can list comments for an issue."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='more info', user_id=111,
+ issue_id=issue.issue_id)
+ self.services.issue.TestAddComment(comment, 1)
+
+ with self.work_env as we:
+ actual_comments = we.ListIssueComments(issue)
+
+ self.assertEqual(2, len(actual_comments))
+ self.assertEqual('sum', actual_comments[0].content)
+ self.assertEqual('more info', actual_comments[1].content)
+
+ def _Comment(self, issue, content, local_id, approval_id=None):
+ """Adds a comment to issue with reasonable defaults."""
+ comment = tracker_pb2.IssueComment(
+ project_id=issue.project_id,
+ content=content,
+ user_id=issue.reporter_id,
+ issue_id=issue.issue_id,
+ approval_id=approval_id)
+ self.services.issue.TestAddComment(comment, local_id)
+
+ def testSafeListIssueComments_Normal(self):
+ initial_description = 'sum'
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ initial_description,
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+ self._Comment(issue, 'more info', 1)
+
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(issue.issue_id, 1000, 0)
+
+ self.assertEqual(None, list_result.next_start)
+ actual_comments = list_result.items
+ self.assertEqual(2, len(actual_comments))
+ self.assertEqual(initial_description, actual_comments[0].content)
+ self.assertEqual('more info', actual_comments[1].content)
+
+
+ def testSafeListIssueComments_DeletedIssue(self):
+ """Users without permissions cannot view comments on deleted issues."""
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ 'sum',
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ issue.deleted = True
+ self.services.issue.TestAddIssue(issue)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.SafeListIssueComments(issue.issue_id, 1000, 0)
+
+ def testSafeListIssueComments_NotAllowed(self):
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ 'sum',
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name,
+ labels=['Restrict-View-CoreTeam'])
+ self.services.issue.TestAddIssue(issue)
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.SafeListIssueComments(issue.issue_id, 1000, 0)
+
+ def testSafeListIssueComments_UserFlagged(self):
+ """Users see comments they flagged as spam."""
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ 'sum',
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+ flagged_comment = tracker_pb2.IssueComment(
+ project_id=self.project.project_id,
+ content='flagged content',
+ user_id=self.user_1.user_id,
+ issue_id=issue.issue_id,
+ inbound_message='Some message',
+ importer_id=self.user_1.user_id)
+ self.services.issue.TestAddComment(flagged_comment, 1)
+
+ self.services.spam.FlagComment(
+ self.cnxn, issue, flagged_comment.id, flagged_comment.user_id,
+ self.user_2.user_id, True)
+
+ # One user flagging a comment doesn't cause other users to see it as spam.
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(issue.issue_id, 1000, 0)
+ self.assertFalse(list_result.items[1].is_spam)
+
+ self.SignIn(self.user_2.user_id)
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(issue.issue_id, 1000, 0)
+ self.assertTrue(list_result.items[1].is_spam)
+ self.assertEqual('flagged content', list_result.items[1].content)
+
+ def testSafeListIssueComments_FilteredContent(self):
+
+ def AssertFiltered(comment, filtered_comment):
+ # Unfiltered
+ self.assertEqual(comment.id, filtered_comment.id)
+ self.assertEqual(comment.issue_id, filtered_comment.issue_id)
+ self.assertEqual(comment.project_id, filtered_comment.project_id)
+ self.assertEqual(comment.approval_id, filtered_comment.approval_id)
+ self.assertEqual(comment.timestamp, filtered_comment.timestamp)
+ self.assertEqual(comment.deleted_by, filtered_comment.deleted_by)
+ self.assertEqual(comment.sequence, filtered_comment.sequence)
+ self.assertEqual(comment.is_spam, filtered_comment.is_spam)
+ self.assertEqual(comment.is_description, filtered_comment.is_description)
+ self.assertEqual(
+ comment.description_num, filtered_comment.description_num)
+ # Filtered.
+ self.assertEqual(None, filtered_comment.content)
+ self.assertEqual(0, filtered_comment.user_id)
+ self.assertEqual([], filtered_comment.amendments)
+ self.assertEqual([], filtered_comment.attachments)
+ self.assertEqual(None, filtered_comment.inbound_message)
+ self.assertEqual(0, filtered_comment.importer_id)
+
+ initial_description = 'sum'
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ initial_description,
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+ spam_comment = tracker_pb2.IssueComment(
+ project_id=self.project.project_id,
+ content='spam',
+ user_id=self.user_1.user_id,
+ issue_id=issue.issue_id,
+ is_spam=True,
+ inbound_message='Some message',
+ importer_id=self.user_1.user_id)
+ deleted_comment = tracker_pb2.IssueComment(
+ project_id=self.project.project_id,
+ content='deleted',
+ user_id=self.user_1.user_id,
+ issue_id=issue.issue_id,
+ deleted_by=self.user_1.user_id,
+ amendments=[
+ tracker_pb2.Amendment(
+ field=tracker_pb2.FieldID.SUMMARY, newvalue='new')
+ ],
+ attachments=[
+ tracker_pb2.Attachment(
+ attachment_id=1,
+ mimetype='image/png',
+ filename='example.png',
+ filesize=12345)
+ ])
+ inbound_comment = tracker_pb2.IssueComment(
+ project_id=self.project.project_id,
+ content='from an inbound message',
+ user_id=self.user_1.user_id,
+ issue_id=issue.issue_id,
+ inbound_message='the full inbound message')
+ self.services.issue.TestAddComment(spam_comment, 1)
+ self.services.issue.TestAddComment(deleted_comment, 2)
+ self.services.issue.TestAddComment(inbound_comment, 3)
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(issue.issue_id, 1000, 0)
+
+ self.assertEqual(None, list_result.next_start)
+ actual_comments = list_result.items
+ self.assertEqual(4, len(actual_comments))
+ self.assertEqual(initial_description, actual_comments[0].content)
+ AssertFiltered(spam_comment, actual_comments[1])
+ AssertFiltered(deleted_comment, actual_comments[2])
+ self.assertEqual('from an inbound message', actual_comments[3].content)
+ self.assertEqual(None, actual_comments[3].inbound_message)
+
+ def testSafeListIssueComments_AdminsViewUnfiltered(self):
+ """Admins can appropriately view comment content that would be filtered."""
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ 'sum',
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+ spam_comment = tracker_pb2.IssueComment(
+ project_id=self.project.project_id,
+ content='spam',
+ user_id=self.user_1.user_id,
+ issue_id=issue.issue_id,
+ is_spam=True,
+ inbound_message='Some message',
+ importer_id=self.user_1.user_id)
+ deleted_comment = tracker_pb2.IssueComment(
+ project_id=self.project.project_id,
+ content='deleted',
+ user_id=self.user_1.user_id,
+ issue_id=issue.issue_id,
+ deleted_by=self.user_1.user_id,
+ amendments=[
+ tracker_pb2.Amendment(
+ field=tracker_pb2.FieldID.SUMMARY, newvalue='new')
+ ],
+ attachments=[
+ tracker_pb2.Attachment(
+ attachment_id=1,
+ mimetype='image/png',
+ filename='example.png',
+ filesize=12345)
+ ])
+ inbound_comment = tracker_pb2.IssueComment(
+ project_id=self.project.project_id,
+ content='from an inbound message',
+ user_id=self.user_1.user_id,
+ issue_id=issue.issue_id,
+ inbound_message='the full inbound message')
+ self.services.issue.TestAddComment(spam_comment, 1)
+ self.services.issue.TestAddComment(deleted_comment, 2)
+ self.services.issue.TestAddComment(inbound_comment, 3)
+
+ self.SignIn(self.admin_user.user_id)
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(issue.issue_id, 1000, 0)
+
+ # Admins can view the fields of comments that would be filtered.
+ actual_comments = list_result.items
+ self.assertEqual(spam_comment.content, actual_comments[1].content)
+ self.assertEqual(deleted_comment.content, actual_comments[2].content)
+ self.assertEqual(
+ 'the full inbound message', actual_comments[3].inbound_message)
+
+ def testSafeListIssueComments_MoreItems(self):
+ initial_description = 'sum'
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ initial_description,
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+ self._Comment(issue, 'more info', 1)
+
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(issue.issue_id, 1, 0)
+
+ self.assertEqual(1, list_result.next_start)
+ actual_comments = list_result.items
+ self.assertEqual(1, len(actual_comments))
+ self.assertEqual(initial_description, actual_comments[0].content)
+
+ def testSafeListIssueComments_Start(self):
+ initial_description = 'sum'
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ initial_description,
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+ self._Comment(issue, 'more info', 1)
+
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(issue.issue_id, 1000, 1)
+ self.assertEqual(None, list_result.next_start)
+ actual_comments = list_result.items
+ self.assertEqual(1, len(actual_comments))
+ self.assertEqual('more info', actual_comments[0].content)
+
+ def testSafeListIssueComments_ApprovalId(self):
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ 'initial description',
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+
+ max_items = 2
+ # Create comments for testing.
+ self._Comment(issue, 'more info', 1)
+ self._Comment(issue, 'approval2 info', 2, approval_id=2)
+ # This would be after the max_items of 2, so we are ensuring that the
+ # max_items limit applies AFTER filtering rather than before.
+ self._Comment(issue, 'approval1 info1', 3, approval_id=1)
+ self._Comment(issue, 'approval1 info2', 4, approval_id=1)
+ self._Comment(issue, 'approval1 info3', 5, approval_id=1)
+
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(
+ issue.issue_id, max_items, 0, approval_id=1)
+ self.assertEqual(
+ 2, list_result.next_start, 'We have a third approval comment')
+ actual_comments = list_result.items
+ self.assertEqual(2, len(actual_comments))
+ self.assertEqual('approval1 info1', actual_comments[0].content)
+ self.assertEqual('approval1 info2', actual_comments[1].content)
+
+ def testSafeListIssueComments_StartAndApprovalId(self):
+ issue = fake.MakeTestIssue(
+ self.project.project_id,
+ 1,
+ 'initial description',
+ 'New',
+ self.user_1.user_id,
+ issue_id=78901,
+ project_name=self.project.project_name)
+ self.services.issue.TestAddIssue(issue)
+
+ # Create comments for testing.
+ self._Comment(issue, 'more info', 1)
+ self._Comment(issue, 'approval2 info', 2, approval_id=2)
+ self._Comment(issue, 'approval1 info1', 3, approval_id=1)
+ self._Comment(issue, 'approval1 info2', 4, approval_id=1)
+ self._Comment(issue, 'approval1 info3', 5, approval_id=1)
+
+ with self.work_env as we:
+ list_result = we.SafeListIssueComments(
+ issue.issue_id, 1000, 1, approval_id=1)
+ self.assertEqual(None, list_result.next_start)
+ actual_comments = list_result.items
+ self.assertEqual(2, len(actual_comments))
+ self.assertEqual('approval1 info2', actual_comments[0].content)
+ self.assertEqual('approval1 info3', actual_comments[1].content)
+
+ # FUTURE: UpdateComment()
+
+ def testDeleteComment_Normal(self):
+ """We can mark and unmark a comment as deleted."""
+ self.SignIn(user_id=111)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id)
+ self.services.issue.TestAddComment(comment, 1)
+ with self.work_env as we:
+ we.DeleteComment(issue, comment, True)
+ self.assertEqual(111, comment.deleted_by)
+ we.DeleteComment(issue, comment, False)
+ self.assertEqual(None, comment.deleted_by)
+
+ @mock.patch('services.issue_svc.IssueService.SoftDeleteComment')
+ def testDeleteComment_UndeleteableSpam(self, mockSoftDeleteComment):
+ """Throws exception when comment is spam and owner is deleting."""
+ self.SignIn(user_id=111)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id, is_spam=True)
+ self.services.issue.TestAddComment(comment, 1)
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.DeleteComment(issue, comment, True)
+ self.assertEqual(None, comment.deleted_by)
+ mockSoftDeleteComment.assert_not_called()
+
+ @mock.patch('services.issue_svc.IssueService.SoftDeleteComment')
+ @mock.patch('framework.permissions.CanDeleteComment')
+ def testDeleteComment_UndeletablePermissions(self, mockCanDelete,
+ mockSoftDeleteComment):
+ """Throws exception when deleter doesn't have permission to do so."""
+ mockCanDelete.return_value = False
+ self.SignIn(user_id=111)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id, is_spam=True)
+ self.services.issue.TestAddComment(comment, 1)
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.DeleteComment(issue, comment, True)
+ self.assertEqual(None, comment.deleted_by)
+ mockSoftDeleteComment.assert_not_called()
+
+ def testDeleteAttachment_Normal(self):
+ """We can mark and unmark a comment attachment as deleted."""
+ self.SignIn(user_id=111)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id)
+ self.services.issue.TestAddComment(comment, 1)
+ attachment = tracker_pb2.Attachment()
+ self.services.issue.TestAddAttachment(attachment, comment.id, 1)
+ with self.work_env as we:
+ we.DeleteAttachment(
+ issue, comment, attachment.attachment_id, True)
+ self.assertTrue(attachment.deleted)
+ we.DeleteAttachment(
+ issue, comment, attachment.attachment_id, False)
+ self.assertFalse(attachment.deleted)
+
+ @mock.patch('services.issue_svc.IssueService.SoftDeleteComment')
+ @mock.patch('framework.permissions.CanDeleteComment')
+ def testDeleteAttachment_UndeletablePermissions(
+ self, mockCanDelete, mockSoftDeleteComment):
+ """Throws exception when deleter doesn't have permission to do so."""
+ mockCanDelete.return_value = False
+ self.SignIn(user_id=111)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id, is_spam=True)
+ self.services.issue.TestAddComment(comment, 1)
+ attachment = tracker_pb2.Attachment()
+ self.services.issue.TestAddAttachment(attachment, comment.id, 1)
+ self.assertFalse(attachment.deleted)
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.DeleteAttachment(
+ issue, comment, attachment.attachment_id, True)
+ self.assertFalse(attachment.deleted)
+ mockSoftDeleteComment.assert_not_called()
+
+ def testFlagComment_Normal(self):
+ """We can mark and unmark a comment as spam."""
+ self.SignIn(user_id=111)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id)
+ self.services.issue.TestAddComment(comment, 1)
+
+ comment_reports = self.services.spam.comment_reports_by_issue_id
+ with self.work_env as we:
+ we.FlagComment(issue, comment, True)
+ self.assertEqual([111], comment_reports[issue.issue_id][comment.id])
+ we.FlagComment(issue, comment, False)
+ self.assertEqual([], comment_reports[issue.issue_id][comment.id])
+
+ def testFlagComment_AutoVerdict(self):
+ """Admins can mark and unmark a comment as spam, and it is a verdict."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id)
+ self.services.issue.TestAddComment(comment, 1)
+
+ comment_reports = self.services.spam.comment_reports_by_issue_id
+ manual_verdicts = self.services.spam.manual_verdicts_by_comment_id
+ with self.work_env as we:
+ we.FlagComment(issue, comment, True)
+ self.assertEqual([444], comment_reports[issue.issue_id][comment.id])
+ self.assertTrue(manual_verdicts[comment.id][444])
+ we.FlagComment(issue, comment, False)
+ self.assertEqual([], comment_reports[issue.issue_id][comment.id])
+ self.assertFalse(manual_verdicts[comment.id][444])
+
+ def testFlagComment_NotAllowed(self):
+ """Anons can't mark comment as spam."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ comment = tracker_pb2.IssueComment(
+ project_id=789, content='soon to be deleted', user_id=111,
+ issue_id=issue.issue_id)
+ self.services.issue.TestAddComment(comment, 1)
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.FlagComment(issue, comment, True)
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.FlagComment(issue, comment, False)
+
+ def testStarIssue_Normal(self):
+ """We can star and unstar issues."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ self.SignIn(user_id=111)
+
+ with self.work_env as we:
+ updated_issue = we.StarIssue(issue, True)
+ self.assertEqual(1, updated_issue.star_count)
+ updated_issue = we.StarIssue(issue, False)
+ self.assertEqual(0, updated_issue.star_count)
+
+ def testStarIssue_Anon(self):
+ """A signed out user cannot star or unstar issues."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ # Don't sign in.
+
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.StarIssue(issue, True)
+
+ def testIsIssueStarred_Normal(self):
+ """We can check if the current user starred an issue or not."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ self.SignIn(user_id=111)
+
+ with self.work_env as we:
+ self.assertFalse(we.IsIssueStarred(issue))
+ we.StarIssue(issue, True)
+ self.assertTrue(we.IsIssueStarred(issue))
+ we.StarIssue(issue, False)
+ self.assertFalse(we.IsIssueStarred(issue))
+
+ def testIsIssueStarred_Anon(self):
+ """A signed out user has never starred anything."""
+ issue = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ # Don't sign in.
+
+ with self.work_env as we:
+ self.assertFalse(we.IsIssueStarred(issue))
+
+ def testListStarredIssueIDs_Anon(self):
+ """A signed out users has no starred issues."""
+ # Don't sign in.
+ with self.work_env as we:
+ self.assertEqual([], we.ListStarredIssueIDs())
+
+ def testListStarredIssueIDs_Normal(self):
+ """We can get the list of issues starred by a user."""
+ issue1 = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ issue2 = fake.MakeTestIssue(789, 2, 'sum2', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue2)
+
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ # User has not starred anything yet.
+ self.assertEqual([], we.ListStarredIssueIDs())
+
+ # Now, star a couple of issues.
+ we.StarIssue(issue1, True)
+ we.StarIssue(issue2, True)
+ self.assertItemsEqual(
+ [issue1.issue_id, issue2.issue_id],
+ we.ListStarredIssueIDs())
+
+ # Check that there is no cross-talk between users.
+ self.SignIn(user_id=222)
+ with self.work_env as we:
+ # User has not starred anything yet.
+ self.assertEqual([], we.ListStarredIssueIDs())
+
+ # Now, star an issue as that other user.
+ we.StarIssue(issue1, True)
+ self.assertEqual([issue1.issue_id], we.ListStarredIssueIDs())
+
+ def testGetUser(self):
+ """We return the User PB for the given existing user id."""
+ expected = self.services.user.TestAddUser('test5@example.com', 555)
+ with self.work_env as we:
+ actual = we.GetUser(555)
+ self.assertEqual(expected, actual)
+
+ def testBatchGetUsers(self):
+ """We return the User PBs for all given user ids."""
+ actual = self.work_env.BatchGetUsers(
+ [self.user_1.user_id, self.user_2.user_id])
+ self.assertEqual(actual, [self.user_1, self.user_2])
+
+ def testBatchGetUsers_NoUserFound(self):
+ """We raise an exception if a User is not found."""
+ with self.assertRaises(exceptions.NoSuchUserException):
+ self.work_env.BatchGetUsers(
+ [self.user_1.user_id, self.user_2.user_id, 404])
+
+ def testGetUser_DoesntExist(self):
+ """We reject attempts to get an user that doesn't exist."""
+ with self.assertRaises(exceptions.NoSuchUserException):
+ with self.work_env as we:
+ we.GetUser(555)
+
+ def setUpUserGroups(self):
+ self.services.user.TestAddUser('test5@example.com', 555)
+ self.services.user.TestAddUser('test6@example.com', 666)
+ public_group_id = self.services.usergroup.CreateGroup(
+ self.cnxn, self.services, 'group1@test.com', 'anyone')
+ private_group_id = self.services.usergroup.CreateGroup(
+ self.cnxn, self.services, 'group2@test.com', 'owners')
+ self.services.usergroup.UpdateMembers(
+ self.cnxn, public_group_id, [111], 'member')
+ self.services.usergroup.UpdateMembers(
+ self.cnxn, private_group_id, [555, 111], 'owner')
+ return public_group_id, private_group_id
+
+ def testGetMemberships_Anon(self):
+ """We return groups the user is in and that are visible to the requester."""
+ public_group_id, _ = self.setUpUserGroups()
+ with self.work_env as we:
+ self.assertEqual(we.GetMemberships(111), [public_group_id])
+
+ def testGetMemberships_UserHasPerm(self):
+ public_group_id, private_group_id = self.setUpUserGroups()
+ self.SignIn(user_id=555)
+ with self.work_env as we:
+ self.assertItemsEqual(
+ we.GetMemberships(111), [public_group_id, private_group_id])
+
+ def testGetMemeberships_UserHasNoPerm(self):
+ public_group_id, _ = self.setUpUserGroups()
+ self.SignIn(user_id=666)
+ with self.work_env as we:
+ self.assertItemsEqual(
+ we.GetMemberships(111), [public_group_id])
+
+ def testGetMemeberships_GetOwnMembership(self):
+ public_group_id, private_group_id = self.setUpUserGroups()
+ self.SignIn(user_id=111)
+ with self.work_env as we:
+ self.assertItemsEqual(
+ we.GetMemberships(111), [public_group_id, private_group_id])
+
+ def testListReferencedUsers(self):
+ """We return the list of User PBs for the given existing user emails."""
+ user5 = self.services.user.TestAddUser('test5@example.com', 555)
+ user6 = self.services.user.TestAddUser('test6@example.com', 666)
+ with self.work_env as we:
+ # We ignore emails that are empty or belong to non-existent users.
+ users, linked_user_ids = we.ListReferencedUsers(
+ ['test4@example.com', 'test5@example.com', 'test6@example.com', ''])
+ self.assertItemsEqual(users, [user5, user6])
+ self.assertEqual(linked_user_ids, [])
+
+ def testListReferencedUsers_Linked(self):
+ """We return User PBs and the IDs of any linked accounts."""
+ user5 = self.services.user.TestAddUser('test5@example.com', 555)
+ user5.linked_child_ids = [666, 777]
+ user6 = self.services.user.TestAddUser('test6@example.com', 666)
+ user6.linked_parent_id = 555
+ with self.work_env as we:
+ # We ignore emails that are empty or belong to non-existent users.
+ users, linked_user_ids = we.ListReferencedUsers(
+ ['test4@example.com', 'test5@example.com', 'test6@example.com', ''])
+ self.assertItemsEqual(users, [user5, user6])
+ self.assertItemsEqual(linked_user_ids, [555, 666, 777])
+
+ def testStarUser_Normal(self):
+ """We can star and unstar a user."""
+ self.SignIn()
+ with self.work_env as we:
+ self.assertFalse(we.IsUserStarred(111))
+ we.StarUser(111, True)
+ self.assertTrue(we.IsUserStarred(111))
+ we.StarUser(111, False)
+ self.assertFalse(we.IsUserStarred(111))
+
+ def testStarUser_NoSuchUser(self):
+ """We can't star a nonexistent user."""
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchUserException):
+ with self.work_env as we:
+ we.StarUser(999, True)
+
+ def testStarUser_Anon(self):
+ """Anon user can't star a user."""
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.StarUser(111, True)
+
+ def testIsUserStarred_Normal(self):
+ """We can check if a user is starred."""
+ # Tested by method testStarUser_Normal().
+ pass
+
+ def testIsUserStarred_NoUserSpecified(self):
+ """A user ID must be specified."""
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ self.assertFalse(we.IsUserStarred(None))
+
+ def testIsUserStarred_NoSuchUser(self):
+ """We can't check for stars on a nonexistent user."""
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchUserException):
+ with self.work_env as we:
+ we.IsUserStarred(999)
+
+ def testGetUserStarCount_Normal(self):
+ """We can count the stars of a user."""
+ self.SignIn()
+ with self.work_env as we:
+ self.assertEqual(0, we.GetUserStarCount(111))
+ we.StarUser(111, True)
+ self.assertEqual(1, we.GetUserStarCount(111))
+
+ self.SignIn(user_id=self.admin_user.user_id)
+ with self.work_env as we:
+ we.StarUser(111, True)
+ self.assertEqual(2, we.GetUserStarCount(111))
+ we.StarUser(111, False)
+ self.assertEqual(1, we.GetUserStarCount(111))
+
+ def testGetUserStarCount_NoSuchUser(self):
+ """We can't count stars of a nonexistent user."""
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchUserException):
+ with self.work_env as we:
+ we.GetUserStarCount(111111)
+
+ def testGetUserStarCount_NoUserSpecified(self):
+ """A user ID must be specified."""
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ self.assertFalse(we.GetUserStarCount(None))
+
+ def testGetPendingLinkInvites_Anon(self):
+ """Anon never had pending linkage invites."""
+ with self.work_env as we:
+ as_parent, as_child = we.GetPendingLinkedInvites()
+ self.assertEqual([], as_parent)
+ self.assertEqual([], as_child)
+
+ def testGetPendingLinkInvites_None(self):
+ """When an account has no invites, we see empty lists."""
+ self.SignIn()
+ with self.work_env as we:
+ as_parent, as_child = we.GetPendingLinkedInvites()
+ self.assertEqual([], as_parent)
+ self.assertEqual([], as_child)
+
+ def testGetPendingLinkInvites_Some(self):
+ """If there are any pending invites for the current user, we get them."""
+ self.SignIn()
+ self.services.user.invite_rows = [(111, 222), (333, 444), (555, 111)]
+ with self.work_env as we:
+ as_parent, as_child = we.GetPendingLinkedInvites()
+ self.assertEqual([222], as_parent)
+ self.assertEqual([555], as_child)
+
+ def testInviteLinkedParent_MissingParent(self):
+ """Invited parent must be specified by email."""
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ we.InviteLinkedParent('')
+
+ def testInviteLinkedParent_Anon(self):
+ """Anon cannot invite anyone to link accounts."""
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.InviteLinkedParent('x@example.com')
+
+ def testInviteLinkedParent_NotAMatch(self):
+ """We only allow linkage invites when usernames match."""
+ self.SignIn()
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException) as cm:
+ we.InviteLinkedParent('x@example.com')
+ self.assertEqual('Linked account names must match', cm.exception.message)
+
+ @mock.patch('settings.linkable_domains', {'example.com': ['other.com']})
+ def testInviteLinkedParent_BadDomain(self):
+ """We only allow linkage invites between allowlisted domains."""
+ self.SignIn()
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException) as cm:
+ we.InviteLinkedParent('user_111@hacker.com')
+ self.assertEqual(
+ 'Linked account unsupported domain', cm.exception.message)
+
+ @mock.patch('settings.linkable_domains', {'example.com': ['other.com']})
+ def testInviteLinkedParent_NoSuchParent(self):
+ """Verify that the parent account already exists."""
+ self.SignIn()
+ with self.work_env as we:
+ with self.assertRaises(exceptions.NoSuchUserException):
+ we.InviteLinkedParent('user_111@other.com')
+
+ @mock.patch('settings.linkable_domains', {'example.com': ['other.com']})
+ def testInviteLinkedParent_Normal(self):
+ """A child account can invite a matching parent account to link."""
+ self.services.user.TestAddUser('user_111@other.com', 555)
+ self.SignIn()
+ with self.work_env as we:
+ we.InviteLinkedParent('user_111@other.com')
+ self.assertEqual(
+ [(555, 111)], self.services.user.invite_rows)
+
+ def testAcceptLinkedChild_NoInvite(self):
+ """A parent account can only accept an exiting invite."""
+ self.SignIn()
+ self.services.user.invite_rows = [(111, 222)]
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ we.AcceptLinkedChild(333)
+
+ self.SignIn(user_id=222)
+ self.services.user.invite_rows = [(111, 333)]
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ we.AcceptLinkedChild(333)
+
+ def testAcceptLinkedChild_Normal(self):
+ """A parent account can accept an invite from a child."""
+ self.SignIn()
+ self.services.user.invite_rows = [(111, 222)]
+ with self.work_env as we:
+ we.AcceptLinkedChild(222)
+ self.assertEqual(
+ [(111, 222)], self.services.user.linked_account_rows)
+ self.assertEqual(
+ [], self.services.user.invite_rows)
+
+ def testUnlinkAccounts_NotAllowed(self):
+ """Reject attempts to unlink someone else's accounts."""
+ self.SignIn(user_id=333)
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.UnlinkAccounts(111, 222)
+
+ def testUnlinkAccounts_AdminIsAllowed(self):
+ """Site admins may unlink someone else's accounts."""
+ self.SignIn(user_id=444)
+ self.services.user.linked_account_rows = [(111, 222)]
+ with self.work_env as we:
+ we.UnlinkAccounts(111, 222)
+ self.assertNotIn((111, 222), self.services.user.linked_account_rows)
+
+ def testUnlinkAccounts_Normal(self):
+ """A parent or child can unlink their linked account."""
+ self.SignIn(user_id=111)
+ self.services.user.linked_account_rows = [(111, 222), (333, 444)]
+ with self.work_env as we:
+ we.UnlinkAccounts(111, 222)
+ self.assertEqual([(333, 444)], self.services.user.linked_account_rows)
+
+ self.SignIn(user_id=222)
+ self.services.user.linked_account_rows = [(111, 222), (333, 444)]
+ with self.work_env as we:
+ we.UnlinkAccounts(111, 222)
+ self.assertEqual([(333, 444)], self.services.user.linked_account_rows)
+
+ def testUpdateUserSettings(self):
+ """We can update the settings of the logged in user."""
+ self.SignIn()
+ user = self.services.user.GetUser(self.cnxn, 111)
+ with self.work_env as we:
+ we.UpdateUserSettings(
+ user,
+ obscure_email=True,
+ keep_people_perms_open=True)
+
+ self.assertTrue(user.obscure_email)
+ self.assertTrue(user.keep_people_perms_open)
+
+ def testUpdateUserSettings_Anon(self):
+ """A user must be logged in."""
+ anon = self.services.user.GetUser(self.cnxn, 0)
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ we.UpdateUserSettings(anon, keep_people_perms_open=True)
+
+ def testGetUserPrefs_Anon(self):
+ """Anon always has empty prefs."""
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(0)
+
+ self.assertEqual(0, userprefs.user_id)
+ self.assertEqual([], userprefs.prefs)
+
+ def testGetUserPrefs_Mine_Empty(self):
+ """User who never set any pref gets empty prefs."""
+ self.SignIn()
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(111)
+
+ self.assertEqual(111, userprefs.user_id)
+ self.assertEqual([], userprefs.prefs)
+
+ def testGetUserPrefs_Mine_Some(self):
+ """User who set a pref gets it back."""
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+ self.SignIn()
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(111)
+
+ self.assertEqual(111, userprefs.user_id)
+ self.assertEqual(1, len(userprefs.prefs))
+ self.assertEqual('code_font', userprefs.prefs[0].name)
+ self.assertEqual('true', userprefs.prefs[0].value)
+
+ def testGetUserPrefs_Other_Allowed(self):
+ """A site admin can read another user's prefs."""
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+ self.SignIn(user_id=self.admin_user.user_id)
+
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(111)
+
+ self.assertEqual(111, userprefs.user_id)
+ self.assertEqual(1, len(userprefs.prefs))
+ self.assertEqual('code_font', userprefs.prefs[0].name)
+ self.assertEqual('true', userprefs.prefs[0].value)
+
+ def testGetUserPrefs_Other_Denied(self):
+ """A non-admin cannot read another user's prefs."""
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+ # user2 is not a site admin.
+ self.SignIn(222)
+
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.GetUserPrefs(111)
+
+ def _SetUpCorpUsers(self, user_ids):
+ self.services.user.TestAddUser('corp_group@example.com', 888)
+ self.services.usergroup.TestAddGroupSettings(
+ 888, 'corp_group@example.com')
+ self.services.usergroup.TestAddMembers(888, user_ids)
+
+ # TODO(jrobbins): Update this with user group prefs when implemented.
+ @mock.patch(
+ 'settings.restrict_new_issues_user_groups', ['corp_group@example.com'])
+ def testGetUserPrefs_Mine_RestrictNewIssues(self):
+ """User who belongs to restrict_new_issues user group gets those prefs."""
+ self._SetUpCorpUsers([111, 222])
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+ self.SignIn()
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(111)
+
+ self.assertEqual(111, userprefs.user_id)
+ self.assertEqual(2, len(userprefs.prefs))
+ self.assertEqual('code_font', userprefs.prefs[0].name)
+ self.assertEqual('true', userprefs.prefs[0].value)
+ self.assertEqual('restrict_new_issues', userprefs.prefs[1].name)
+ self.assertEqual('true', userprefs.prefs[1].value)
+
+ @mock.patch(
+ 'settings.restrict_new_issues_user_groups', ['corp_group@example.com'])
+ def testGetUserPrefs_Mine_RestrictNewIssues_OptedOut(self):
+ """If a restrict_new_issues user has opted out, use that pref value."""
+ self._SetUpCorpUsers([111, 222])
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='restrict_new_issues', value='false')])
+ self.SignIn()
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(111)
+
+ self.assertEqual(111, userprefs.user_id)
+ self.assertEqual(1, len(userprefs.prefs))
+ self.assertEqual('restrict_new_issues', userprefs.prefs[0].name)
+ self.assertEqual('false', userprefs.prefs[0].value)
+
+ # TODO(jrobbins): Update this with user group prefs when implemented.
+ @mock.patch(
+ 'settings.public_issue_notice_user_groups', ['corp_group@example.com'])
+ def testGetUserPrefs_Mine_PublicIssueNotice(self):
+ """User who belongs to public_issue_notice user group gets those prefs."""
+ self._SetUpCorpUsers([111, 222])
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+ self.SignIn()
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(111)
+
+ self.assertEqual(111, userprefs.user_id)
+ self.assertEqual(2, len(userprefs.prefs))
+ self.assertEqual('code_font', userprefs.prefs[0].name)
+ self.assertEqual('true', userprefs.prefs[0].value)
+ self.assertEqual('public_issue_notice', userprefs.prefs[1].name)
+ self.assertEqual('true', userprefs.prefs[1].value)
+
+ @mock.patch(
+ 'settings.public_issue_notice_user_groups', ['corp_group@example.com'])
+ def testGetUserPrefs_Mine_PublicIssueNotice_OptedOut(self):
+ """If a public_issue_notice user has opted out, use that pref value."""
+ self._SetUpCorpUsers([111, 222])
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='public_issue_notice', value='false')])
+ self.SignIn()
+ with self.work_env as we:
+ userprefs = we.GetUserPrefs(111)
+
+ self.assertEqual(111, userprefs.user_id)
+ self.assertEqual(1, len(userprefs.prefs))
+ self.assertEqual('public_issue_notice', userprefs.prefs[0].name)
+ self.assertEqual('false', userprefs.prefs[0].value)
+
+ def testSetUserPrefs_Anon(self):
+ """Anon cannot set prefs."""
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ we.SetUserPrefs(0, [])
+
+ def testSetUserPrefs_Mine_Empty(self):
+ """Setting zero prefs is a no-op.."""
+ self.SignIn(111)
+
+ with self.work_env as we:
+ we.SetUserPrefs(111, [])
+
+ prefs_after = self.services.user.GetUserPrefs(self.cnxn, 111)
+ self.assertEqual(0, len(prefs_after.prefs))
+
+ def testSetUserPrefs_Mine_Add(self):
+ """User can set a preference for the first time."""
+ self.SignIn(111)
+
+ with self.work_env as we:
+ we.SetUserPrefs(
+ 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+
+ prefs_after = self.services.user.GetUserPrefs(self.cnxn, 111)
+ self.assertEqual(1, len(prefs_after.prefs))
+ self.assertEqual('code_font', prefs_after.prefs[0].name)
+ self.assertEqual('true', prefs_after.prefs[0].value)
+
+ def testSetUserPrefs_Mine_Overwrite(self):
+ """User can change the value of a pref."""
+ self.SignIn(111)
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+
+ with self.work_env as we:
+ we.SetUserPrefs(
+ 111,
+ [user_pb2.UserPrefValue(name='code_font', value='false')])
+
+ prefs_after = self.services.user.GetUserPrefs(self.cnxn, 111)
+ self.assertEqual(1, len(prefs_after.prefs))
+ self.assertEqual('code_font', prefs_after.prefs[0].name)
+ self.assertEqual('false', prefs_after.prefs[0].value)
+
+ def testSetUserPrefs_Mine_Bad(self):
+ """User cannot set a preference value that is not valid."""
+ self.SignIn(111)
+
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ we.SetUserPrefs(
+ 111,
+ [user_pb2.UserPrefValue(name='code_font', value='sorta')])
+ with self.assertRaises(exceptions.InputException):
+ we.SetUserPrefs(
+ 111,
+ [user_pb2.UserPrefValue(name='sign', value='gemini')])
+
+ # Regardless of exceptions, nothing was actually stored.
+ prefs_after = self.services.user.GetUserPrefs(self.cnxn, 111)
+ self.assertEqual(0, len(prefs_after.prefs))
+
+ def testSetUserPrefs_Other_Allowed(self):
+ """A site admin can update another user's prefs."""
+ self.SignIn(user_id=self.admin_user.user_id)
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+
+ with self.work_env as we:
+ we.SetUserPrefs(
+ 111,
+ [user_pb2.UserPrefValue(name='code_font', value='false')])
+
+ prefs_after = self.services.user.GetUserPrefs(self.cnxn, 111)
+ self.assertEqual(1, len(prefs_after.prefs))
+ self.assertEqual('code_font', prefs_after.prefs[0].name)
+ self.assertEqual('false', prefs_after.prefs[0].value)
+
+ def testSetUserPrefs_Other_Denied(self):
+ """A non-admin cannot set another user's prefs."""
+ # user2 is not a site admin.
+ self.SignIn(222)
+ self.services.user.SetUserPrefs(
+ self.cnxn, 111,
+ [user_pb2.UserPrefValue(name='code_font', value='true')])
+
+ with self.work_env as we:
+ with self.assertRaises(permissions.PermissionException):
+ we.SetUserPrefs(
+ 111,
+ [user_pb2.UserPrefValue(name='code_font', value='false')])
+
+ # Regardless of any exception, the preferences remain unchanged.
+ prefs_after = self.services.user.GetUserPrefs(self.cnxn, 111)
+ self.assertEqual(1, len(prefs_after.prefs))
+ self.assertEqual('code_font', prefs_after.prefs[0].name)
+ self.assertEqual('true', prefs_after.prefs[0].value)
+
+ # FUTURE: GetUser()
+ # FUTURE: UpdateUser()
+ # FUTURE: DeleteUser()
+ # FUTURE: ListStarredUsers()
+
+ def testExpungeUsers_PermissionException(self):
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.ExpungeUsers([])
+
+ def testExpungeUsers_NoUsers(self):
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.usergroup.group_dag = mock.Mock()
+
+ self.mr.perms = permissions.ADMIN_PERMISSIONSET
+ with self.work_env as we:
+ we.ExpungeUsers(['unknown@user.test'])
+
+ self.mr.cnxn.Commit.assert_not_called()
+ self.services.usergroup.group_dag.MarkObsolete.assert_not_called()
+
+ def testExpungeUsers_ReservedUserID(self):
+ self.mr.cnxn = mock.Mock()
+ self.mr.cnxn.Commit = mock.Mock()
+ self.services.usergroup.group_dag = mock.Mock()
+
+ user_1 = self.services.user.TestAddUser(
+ 'tainted-data@user.test', framework_constants.DELETED_USER_ID)
+
+ self.mr.perms = permissions.ADMIN_PERMISSIONSET
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.ExpungeUsers([user_1.email])
+
+ @mock.patch(
+ 'features.send_notifications.'
+ 'PrepareAndSendDeletedFilterRulesNotification')
+ def testExpungeUsers_SkipPermissieons(self, _fake_pasdfrn):
+ self.mr.cnxn = mock.Mock()
+ self.services.usergroup.group_dag = mock.Mock()
+ with self.work_env as we:
+ we.ExpungeUsers([], check_perms=False)
+
+ @mock.patch(
+ 'features.send_notifications.'
+ 'PrepareAndSendDeletedFilterRulesNotification')
+ def testExpungeUsers(self, fake_pasdfrn):
+ """Test user data correctly expunged."""
+ # Replace template service mock with fake testing TemplateService
+ self.services.template = fake.TemplateService()
+
+ wipeout_emails = ['cow@test.com', 'chicken@test.com', 'llama@test.com',
+ 'alpaca@test.com']
+ user_1 = self.services.user.TestAddUser('cow@test.com', 111)
+ user_2 = self.services.user.TestAddUser('chicken@test.com', 222)
+ user_3 = self.services.user.TestAddUser('llama@test.com', 333)
+ user_4 = self.services.user.TestAddUser('random@test.com', 888)
+ ids_by_email = {user_1.email: user_1.user_id, user_2.email: user_2.user_id,
+ user_3.email: user_3.user_id}
+ user_ids = list(ids_by_email.values())
+
+ # set up testing data
+ starred_project_id = 19
+ self.services.project_star._SetStar(self.mr.cnxn, 12, user_1.user_id, True)
+ self.services.user_star.SetStar(
+ self.mr.cnxn, user_2.user_id, user_4.user_id, True)
+ template = self.services.template.TestAddIssueTemplateDef(
+ 13, 16, 'template name', owner_id=user_3.user_id)
+ project1 = self.services.project.TestAddProject(
+ 'project1', owner_ids=[111, 333], project_id=16)
+ project2 = self.services.project.TestAddProject(
+ 'project2',owner_ids=[888], contrib_ids=[111, 222],
+ committer_ids=[333], project_id=17)
+
+ self.services.features.TestAddFilterRule(
+ 16, 'owner:cow@test.com', add_cc_ids=[user_4.user_id])
+ self.services.features.TestAddFilterRule(
+ 16, 'owner:random@test.com',
+ add_cc_ids=[user_2.user_id, user_3.user_id])
+ self.services.features.TestAddFilterRule(
+ 17, 'label:random-label', add_notify=[user_3.email])
+ kept_rule = self.services.features.TestAddFilterRule(
+ 16, 'owner:random@test.com', add_notify=['random2@test.com'])
+
+ self.mr.cnxn = mock.Mock()
+ self.services.usergroup.group_dag = mock.Mock()
+
+ # call ExpungeUsers
+ self.mr.perms = permissions.ADMIN_PERMISSIONSET
+ with self.work_env as we:
+ we.ExpungeUsers(wipeout_emails)
+
+ # Assert users expunged in stars
+ self.assertFalse(self.services.project_star.IsItemStarredBy(
+ self.mr.cnxn, starred_project_id, user_1.user_id))
+ self.assertFalse(self.services.user_star.CountItemStars(
+ self.mr.cnxn, user_2.user_id))
+
+ # Assert users expunged in quick edits and saved queries
+ self.assertItemsEqual(
+ self.services.features.expunged_users_in_quick_edits, user_ids)
+ self.assertItemsEqual(
+ self.services.features.expunged_users_in_saved_queries, user_ids)
+
+ # Assert users expunged in templates and configs
+ self.assertIsNone(template.owner_id)
+ self.assertItemsEqual(
+ self.services.config.expunged_users_in_configs, user_ids)
+
+ # Assert users expunged in projects
+ self.assertEqual(project1.owner_ids, [])
+ self.assertEqual(project2.contributor_ids, [])
+
+ # Assert users expunged in issues
+ self.assertItemsEqual(
+ self.services.issue.expunged_users_in_issues, user_ids)
+ self.assertTrue(self.services.issue.enqueue_issues_called)
+
+ # Assert users expunged in spam
+ self.assertItemsEqual(
+ self.services.spam.expunged_users_in_spam, user_ids)
+
+ # Assert users expunged in hotlists
+ self.assertItemsEqual(
+ self.services.features.expunged_users_in_hotlists, user_ids)
+
+ # Assert users expunged in groups
+ self.assertItemsEqual(
+ self.services.usergroup.expunged_users_in_groups, user_ids)
+
+ # Assert filter rules expunged
+ self.assertEqual(
+ self.services.features.test_rules[16], [kept_rule])
+ self.assertEqual(
+ self.services.features.test_rules[17], [])
+
+ # Assert mocks
+ self.assertEqual(7, len(self.mr.cnxn.Commit.call_args_list))
+ self.services.usergroup.group_dag.MarkObsolete.assert_called_once()
+
+ fake_pasdfrn.assert_has_calls(
+ [mock.call(
+ 16,
+ 'testing-app.appspot.com',
+ ['if owner:%s then add cc(s): random@test.com' % (
+ framework_constants.DELETED_USER_NAME),
+ 'if owner:random@test.com then add cc(s): %s, %s' % (
+ framework_constants.DELETED_USER_NAME,
+ framework_constants.DELETED_USER_NAME)]),
+ mock.call(
+ 17,
+ 'testing-app.appspot.com',
+ ['if label:random-label then notify: %s' % (
+ framework_constants.DELETED_USER_NAME)])
+ ])
+
+ def testTotalUsersCount_WithDeletedUser(self):
+ # Clear users added previously with TestAddUser
+ self.services.user.users_by_id = {}
+ self.services.user.TestAddUser(
+ '', framework_constants.DELETED_USER_ID)
+ self.services.user.TestAddUser('cow@test.com', 111)
+ self.services.user.TestAddUser('chicken@test.com', 222)
+ self.assertEqual(2, self.services.user.TotalUsersCount(self.mr.cnxn))
+
+ def testTotalUsersCount(self):
+ # Clear users added previously with TestAddUser
+ self.services.user.users_by_id = {}
+ self.services.user.TestAddUser('cow@test.com', 111)
+ self.assertEqual(1, self.services.user.TotalUsersCount(self.mr.cnxn))
+
+ def testGetAllUserEmailsBatch(self):
+ # Clear users added previously with TestAddUser
+ self.services.user.users_by_id = {}
+ user_1 = self.services.user.TestAddUser('cow@test.com', 111)
+ user_2 = self.services.user.TestAddUser('chicken@test.com', 222)
+ user_6 = self.services.user.TestAddUser('6@test.com', 666)
+ user_5 = self.services.user.TestAddUser('5@test.com', 555)
+ user_3 = self.services.user.TestAddUser('3@test.com', 333)
+ self.services.user.TestAddUser('4@test.com', 444)
+
+
+ self.assertItemsEqual(
+ [user_1.email, user_2.email, user_3.email],
+ self.services.user.GetAllUserEmailsBatch(self.mr.cnxn, limit=3))
+ self.assertItemsEqual(
+ [user_5.email, user_6.email],
+ self.services.user.GetAllUserEmailsBatch(
+ self.mr.cnxn, limit=3, offset=4))
+
+ # Test existence of deleted user does not change results.
+ self.services.user.TestAddUser(
+ '', framework_constants.DELETED_USER_ID)
+ self.assertItemsEqual(
+ [user_1.email, user_2.email, user_3.email],
+ self.services.user.GetAllUserEmailsBatch(self.mr.cnxn, limit=3))
+ self.assertItemsEqual(
+ [user_5.email, user_6.email],
+ self.services.user.GetAllUserEmailsBatch(
+ self.mr.cnxn, limit=3, offset=4))
+
+ # FUTURE: CreateGroup()
+ # FUTURE: ListGroups()
+ # FUTURE: UpdateGroup()
+ # FUTURE: DeleteGroup()
+
+ def AddIssueToHotlist(self, hotlist_id, issue_id=78901, adder_id=111):
+ self.services.features.AddIssuesToHotlists(
+ self.cnxn, [hotlist_id], [(issue_id, adder_id, 0, '')],
+ None, None, None)
+
+ def testCreateHotlist_Normal(self):
+ """We can create a hotlist."""
+ issue_1 = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue_1)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlist = we.CreateHotlist(
+ 'name', 'summary', 'description', [222], [78901], False,
+ 'priority owner')
+
+ self.assertEqual('name', hotlist.name)
+ self.assertEqual('summary', hotlist.summary)
+ self.assertEqual('description', hotlist.description)
+ self.assertEqual([111], hotlist.owner_ids)
+ self.assertEqual([222], hotlist.editor_ids)
+ self.assertEqual([78901], [item.issue_id for item in hotlist.items])
+ self.assertEqual(False, hotlist.is_private)
+ self.assertEqual('priority owner', hotlist.default_col_spec)
+
+ def testCreateHotlist_NotViewable(self):
+ """We cannot add issues we cannot see to a hotlist."""
+ hotlist_owner_id = 333
+ issue1 = fake.MakeTestIssue(
+ 789, 1, 'sum1', 'New', 111, issue_id=78901,
+ labels=['Restrict-View-Chicken'])
+ self.services.issue.TestAddIssue(issue1)
+
+ self.SignIn(user_id=hotlist_owner_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.CreateHotlist(
+ 'Cow-Hotlist', 'Moo', 'MooMoo', [], [issue1.issue_id], False, '')
+
+ def testCreateHotlist_AnonCantCreateHotlist(self):
+ """We must be signed in to create a hotlist."""
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CreateHotlist('name', 'summary', 'description', [], [222], False, '')
+
+ def testCreateHotlist_InvalidName(self):
+ """We can't create a hotlist with an invalid name."""
+ self.SignIn()
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CreateHotlist(
+ '***Invalid***', 'summary', 'description', [], [], False, '')
+
+ def testCreateHotlist_HotlistAlreadyExists(self):
+ """We can't create a hotlist with a name that already exists."""
+ self.SignIn()
+ with self.work_env as we:
+ we.CreateHotlist('name', 'summary', 'description', [], [], False, '')
+
+ with self.assertRaises(features_svc.HotlistAlreadyExists):
+ with self.work_env as we:
+ we.CreateHotlist('name', 'foo', 'bar', [], [], True, '')
+
+ def testUpdateHotlist(self):
+ """We can update a hotlist."""
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ we.UpdateHotlist(
+ self.hotlist.hotlist_id, hotlist_name=self.hotlist.name,
+ summary='new sum', description='new desc',
+ owner_id=self.user_2.user_id,
+ add_editor_ids=[self.user_1.user_id, self.user_3.user_id],
+ is_private=False)
+ updated_hotlist = we.GetHotlist(self.hotlist.hotlist_id)
+
+ expected_hotlist = features_pb2.Hotlist(
+ hotlist_id=self.hotlist.hotlist_id, name=self.hotlist.name,
+ summary='new sum', description='new desc',
+ owner_ids=[self.user_2.user_id],
+ editor_ids=[self.user_2.user_id,
+ self.user_3.user_id,
+ self.user_1.user_id],
+ is_private=False)
+ self.assertEqual(updated_hotlist, expected_hotlist)
+
+ @mock.patch('testing.fake.FeaturesService.UpdateHotlist')
+ def testUpdateHotlist_NoChanges(self, fake_update_hotlist):
+ """The DB does not get updated if all changes are no-op changes"""
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ we.UpdateHotlist(
+ self.hotlist.hotlist_id, hotlist_name=self.hotlist.name,
+ owner_id=self.user_1.user_id,
+ add_editor_ids=[self.user_1.user_id, self.user_2.user_id],
+ is_private=self.hotlist.is_private,
+ default_col_spec=self.hotlist.default_col_spec,
+ summary=self.hotlist.summary,
+ description=self.hotlist.description)
+ updated_hotlist = we.GetHotlist(self.hotlist.hotlist_id)
+
+ self.assertEqual(updated_hotlist, self.hotlist)
+ fake_update_hotlist.assert_not_called()
+
+ def testUpdateHotlist_HotlistNotFound(self):
+ """Error is thrown when a hotlist is not found."""
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.UpdateHotlist(404)
+
+ def testUpdateHotlist_NoPermissions(self):
+ """Error is thrown when the user doesn't have administer permisisons."""
+ self.SignIn(user_id=self.user_2.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.UpdateHotlist(self.hotlist.hotlist_id)
+
+ def testUpdateHotlist_InvalidName(self):
+ """Error is thrown when proposed new name is invalid."""
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.UpdateHotlist(self.hotlist.hotlist_id, hotlist_name='-Chicken')
+
+ def testUpdateHotlist_HotlistAlreadyExistsOwnerChange(self):
+ """Error is thrown proposed owner has hotlist with same name."""
+ _hotlist_conflict = self.work_env.services.features.TestAddHotlist(
+ 'myhotlist', summary='old sum', owner_ids=[self.user_2.user_id],
+ description='old desc', hotlist_id=458, is_private=True)
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(features_svc.HotlistAlreadyExists):
+ with self.work_env as we:
+ we.UpdateHotlist(self.hotlist.hotlist_id, owner_id=self.user_2.user_id)
+
+ def testUpdateHotlist_HotlistAlreadyExistsNameChange(self):
+ """Error is thrown when owner already has a hotlist with same name as
+ proposed name."""
+ hotlist_conflict = self.work_env.services.features.TestAddHotlist(
+ 'myhotlist2', summary='old sum', owner_ids=[self.user_1.user_id],
+ description='old desc', hotlist_id=458, is_private=True)
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(features_svc.HotlistAlreadyExists):
+ with self.work_env as we:
+ we.UpdateHotlist(
+ self.hotlist.hotlist_id, hotlist_name=hotlist_conflict.name)
+
+ def testUpdateHotlist_HotlistAlreadyExistsNameAndOwnerChange(self):
+ """Error is thrown when new owner already has hotlist with same new name."""
+ hotlist_conflict = self.work_env.services.features.TestAddHotlist(
+ 'myhotlist2', summary='old sum', owner_ids=[self.user_2.user_id],
+ description='old desc', hotlist_id=458, is_private=True)
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(features_svc.HotlistAlreadyExists):
+ with self.work_env as we:
+ we.UpdateHotlist(
+ self.hotlist.hotlist_id, owner_id=self.user_2.user_id,
+ hotlist_name=hotlist_conflict.name)
+
+ def testGetHotlist_Normal(self):
+ """We can get an existing hotlist by hotlist_id."""
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ with self.work_env as we:
+ actual = we.GetHotlist(hotlist.hotlist_id)
+
+ self.assertEqual(hotlist, actual)
+
+ def testGetHotlist_NoneHotlist(self):
+ """We reject attempts to pass a None hotlist_id."""
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ _actual = we.GetHotlist(None)
+
+ def testGetHotlist_NoSuchHotlist(self):
+ """We reject attempts to get a non-existent hotlist."""
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ _actual = we.GetHotlist(999)
+
+ def testListHotlistItems_MoreItems(self):
+ """We can get hotlist's sorted HotlistItems and next start index."""
+ owner_ids = [self.user_1.user_id]
+ issue1 = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', self.user_1.user_id, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ self.services.project.TestAddProject(
+ 'proj', project_id=788, committer_ids=[self.user_1.user_id])
+ issue2 = fake.MakeTestIssue(
+ 788, 2, 'sum', 'New', self.user_1.user_id, issue_id=78802)
+ self.services.issue.TestAddIssue(issue2)
+ issue3 = fake.MakeTestIssue(
+ 789, 3, 'sum', 'New', self.user_3.user_id, issue_id=78803)
+ self.services.issue.TestAddIssue(issue3)
+ base_date = 1205079300
+ hotlist_item_tuples = [
+ (issue1.issue_id, 1, self.user_1.user_id, base_date + 2, 'dude wheres'),
+ (issue2.issue_id, 31, self.user_1.user_id, base_date + 1, 'my car'),
+ (issue3.issue_id, 21, self.user_1.user_id, base_date, '')]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'hotlist', summary='Summary', description='Description',
+ owner_ids=owner_ids, hotlist_id=123,
+ hotlist_item_fields=hotlist_item_tuples)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ max_items = 2
+ start = 0
+ can = 1
+ sort_spec = 'rank'
+ group_by_spec = ''
+ list_result = we.ListHotlistItems(
+ hotlist.hotlist_id, max_items, start, can, sort_spec, group_by_spec)
+
+ expected_items = [
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=issue1.issue_id, rank=1, adder_id=self.user_1.user_id,
+ date_added=base_date + 2, note='dude wheres'),
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=issue3.issue_id, rank=21, adder_id=self.user_1.user_id,
+ date_added=base_date, note='')]
+ self.assertEqual(list_result.items, expected_items)
+
+ self.assertEqual(list_result.next_start, 2)
+
+ def testListHotlistItems_OutOfRange(self):
+ """We can handle out of range `start` and `max_items`."""
+ owner_ids = [self.user_1.user_id]
+ issue1 = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', self.user_1.user_id, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ self.services.project.TestAddProject(
+ 'proj', project_id=788, committer_ids=[self.user_1.user_id])
+ base_date = 1205079300
+ hotlist_item_tuples = [
+ (issue1.issue_id, 1, self.user_1.user_id, base_date + 2, 'dude wheres')]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'hotlist', summary='Summary', description='Description',
+ owner_ids=owner_ids, hotlist_id=123,
+ hotlist_item_fields=hotlist_item_tuples)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ max_items = 10
+ start = 4
+ can = 1
+ sort_spec = ''
+ group_by_spec = ''
+ list_result = we.ListHotlistItems(
+ hotlist.hotlist_id, max_items, start, can, sort_spec, group_by_spec)
+
+ self.assertEqual(list_result.items, [])
+
+ self.assertIsNone(list_result.next_start)
+
+ def testListHotlistItems_InvalidMaxItems(self):
+ """We raise an exception if the given max_items is invalid."""
+ owner_ids = [self.user_1.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'hotlist',
+ summary='Summary',
+ description='Description',
+ owner_ids=owner_ids,
+ hotlist_id=123)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ max_items = -2
+ start = 0
+ can = 1
+ sort_spec = 'rank'
+ group_by_spec = ''
+ we.ListHotlistItems(
+ hotlist.hotlist_id, max_items, start, can, sort_spec, group_by_spec)
+
+ def testListHotlistItems_InvalidStart(self):
+ """We raise an exception if the given start is invalid."""
+ owner_ids = [self.user_1.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'hotlist',
+ summary='Summary',
+ description='Description',
+ owner_ids=owner_ids,
+ hotlist_id=123)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ max_items = 10
+ start = -1
+ can = 1
+ sort_spec = 'rank'
+ group_by_spec = ''
+ we.ListHotlistItems(
+ hotlist.hotlist_id, max_items, start, can, sort_spec, group_by_spec)
+
+
+ def testListHotlistItems_OpenOnly(self):
+ """We can get hotlist's sorted HotlistItems."""
+ base_date = 1205079300
+ owner_ids = [self.user_1.user_id]
+ issue1 = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', self.user_1.user_id, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ issue2 = fake.MakeTestIssue(
+ 789, 2, 'sum', 'Fixed', self.user_1.user_id, issue_id=78902,
+ closed_timestamp=base_date + 10)
+ self.services.issue.TestAddIssue(issue2)
+ hotlist_item_tuples = [
+ (issue1.issue_id, 1, self.user_1.user_id, base_date + 2, 'dude wheres'),
+ (issue2.issue_id, 31, self.user_1.user_id, base_date + 1, 'my car')]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'hotlist', summary='Summary', description='Description',
+ owner_ids=owner_ids, hotlist_id=123,
+ hotlist_item_fields=hotlist_item_tuples)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ max_items = 2
+ start = 0
+ can = 2
+ sort_spec = 'rank'
+ group_by_spec = ''
+ list_result = we.ListHotlistItems(
+ hotlist.hotlist_id, max_items, start, can, sort_spec, group_by_spec)
+
+ expected_items = [
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=issue1.issue_id, rank=1, adder_id=self.user_1.user_id,
+ date_added=base_date + 2, note='dude wheres')]
+ self.assertEqual(list_result.items, expected_items)
+
+ self.assertIsNone(list_result.next_start)
+
+ def testListHotlistItems_HideRestricted(self):
+ """We can get hotlist's sorted HotlistItems."""
+ base_date = 1205079300
+ owner_ids = [self.user_1.user_id]
+ issue1 = fake.MakeTestIssue(
+ 789, 1, 'sum', 'New', self.user_1.user_id, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ self.services.project.TestAddProject(
+ 'proj', project_id=788, committer_ids=[self.user_1.user_id])
+ issue2 = fake.MakeTestIssue(
+ 788, 2, 'sum', 'New', self.user_1.user_id, issue_id=78802,
+ closed_timestamp=base_date + 15)
+ self.services.issue.TestAddIssue(issue2)
+ issue3 = fake.MakeTestIssue(
+ 789, 3, 'sum', 'New', self.user_3.user_id, issue_id=78803,
+ closed_timestamp=base_date + 10,
+ labels=['Restrict-View-Sheep']) # user_1 does not have 'Sheep' perms
+ self.services.issue.TestAddIssue(issue3)
+ hotlist_item_tuples = [
+ (issue1.issue_id, 1, self.user_1.user_id, base_date + 2, 'dude wheres'),
+ (issue3.issue_id, 21, self.user_2.user_id, base_date, ''),
+ (issue2.issue_id, 31, self.user_1.user_id, base_date + 1, 'my car')]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'hotlist', summary='Summary', description='Description',
+ owner_ids=owner_ids, hotlist_id=123,
+ hotlist_item_fields=hotlist_item_tuples)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ max_items = 3
+ start = 0
+ can = 1
+ sort_spec = 'rank'
+ group_by_spec = ''
+ list_result = we.ListHotlistItems(
+ hotlist.hotlist_id, max_items, start, can, sort_spec, group_by_spec)
+
+ expected_items = [
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=issue1.issue_id, rank=1, adder_id=self.user_1.user_id,
+ date_added=base_date + 2, note='dude wheres'),
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=issue2.issue_id, rank=31, adder_id=self.user_1.user_id,
+ date_added=base_date + 1, note='my car')]
+ self.assertEqual(list_result.items, expected_items)
+
+ self.assertIsNone(list_result.next_start)
+
+ def testTransferHotlistOwnership(self):
+ """We can transfer ownership of a hotlist."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'hotlist', summary='Summary', description='Description',
+ owner_ids=owner_ids, editor_ids=editor_ids, hotlist_id=123)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ we.TransferHotlistOwnership(
+ hotlist.hotlist_id, self.user_2.user_id, True)
+ transferred_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(transferred_hotlist.owner_ids, editor_ids)
+ self.assertEqual(transferred_hotlist.editor_ids, owner_ids)
+
+ def testTransferHotlistOwnership_NoPermission(self):
+ """We only let hotlist owners transfer hotlist ownership."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'SameName', summary='Summary', description='Description',
+ owner_ids=owner_ids, editor_ids=editor_ids, hotlist_id=123)
+
+ self.SignIn(user_id=self.user_2.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.TransferHotlistOwnership(
+ hotlist.hotlist_id, self.user_2.user_id, True)
+
+ def testTransferHotlistOwnership_RejectNewOwner(self):
+ """We reject attempts when new owner already owns a
+ hotlist with the same name."""
+ owner_ids = [self.user_1.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'SameName', summary='Summary', description='Description',
+ owner_ids=owner_ids, hotlist_id=123)
+ _other_hotlist = self.work_env.services.features.TestAddHotlist(
+ 'SameName', summary='summary', description='description',
+ owner_ids=[self.user_2.user_id], hotlist_id=124)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.TransferHotlistOwnership(
+ hotlist.hotlist_id, self.user_2.user_id, True)
+
+ def testRemoveHotlistEditors(self):
+ """Hotlist owner can remove editors as normal."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'RejectUnowned',
+ summary='Summary',
+ description='description',
+ owner_ids=owner_ids,
+ editor_ids=editor_ids,
+ hotlist_id=1257)
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ remove_editor_ids = [self.user_2.user_id]
+ we.RemoveHotlistEditors(hotlist.hotlist_id, remove_editor_ids)
+
+ updated_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(updated_hotlist.owner_ids, owner_ids)
+ self.assertEqual(updated_hotlist.editor_ids, [])
+
+ def testRemoveHotlistEditors_NoPermission(self):
+ """A user who is not in the hotlist cannot remove editors."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'RejectUnowned',
+ summary='Summary',
+ description='description',
+ owner_ids=owner_ids,
+ editor_ids=editor_ids,
+ hotlist_id=1257)
+
+ self.SignIn(user_id=self.user_3.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ remove_editor_ids = [self.user_2.user_id]
+ we.RemoveHotlistEditors(hotlist.hotlist_id, remove_editor_ids)
+
+ def testRemoveHotlistEditors_CannotRemoveOtherEditors(self):
+ """A user who is not the hotlist owner cannot remove editors."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id, self.user_3.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'RejectUnowned',
+ summary='Summary',
+ description='description',
+ owner_ids=owner_ids,
+ editor_ids=editor_ids,
+ hotlist_id=1257)
+
+ self.SignIn(user_id=self.user_3.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ remove_editor_ids = [self.user_2.user_id]
+ we.RemoveHotlistEditors(hotlist.hotlist_id, remove_editor_ids)
+
+ def testRemoveHotlistEditors_AllowRemoveSelf(self):
+ """A non-owner member of a hotlist can remove themselves."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'RejectUnowned',
+ summary='Summary',
+ description='description',
+ owner_ids=owner_ids,
+ editor_ids=editor_ids,
+ hotlist_id=1257)
+
+ self.SignIn(user_id=self.user_2.user_id)
+
+ with self.work_env as we:
+ remove_editor_ids = [self.user_2.user_id]
+ we.RemoveHotlistEditors(hotlist.hotlist_id, remove_editor_ids)
+
+ updated_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(updated_hotlist.owner_ids, owner_ids)
+ self.assertEqual(updated_hotlist.editor_ids, [])
+
+ # assert cannot remove someone else
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.RemoveHotlistEditors(hotlist.hotlist_id, [self.user_3.user_id])
+
+ def testRemoveHotlistEditors_AllowRemoveParentLinkedAccount(self):
+ """A non-owner member of a hotlist can remove their linked accounts."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_3.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'RejectUnowned',
+ summary='Summary',
+ description='description',
+ owner_ids=owner_ids,
+ editor_ids=editor_ids,
+ hotlist_id=1257)
+ self.services.user.InviteLinkedParent(
+ self.cnxn, self.user_3.user_id, self.user_2.user_id)
+ self.services.user.AcceptLinkedChild(
+ self.cnxn, self.user_3.user_id, self.user_2.user_id)
+
+ self.SignIn(user_id=self.user_2.user_id)
+ with self.work_env as we:
+ remove_editor_ids = [self.user_3.user_id]
+ we.RemoveHotlistEditors(hotlist.hotlist_id, remove_editor_ids)
+
+ updated_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(updated_hotlist.owner_ids, owner_ids)
+ self.assertEqual(updated_hotlist.editor_ids, [])
+
+ def testRemoveHotlistEditors_AllowRemoveChildLinkedAccount(self):
+ """A non-owner member of a hotlist can remove their linked accounts."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'RejectUnowned',
+ summary='Summary',
+ description='description',
+ owner_ids=owner_ids,
+ editor_ids=editor_ids,
+ hotlist_id=1257)
+ self.services.user.InviteLinkedParent(
+ self.cnxn, self.user_3.user_id, self.user_2.user_id)
+ self.services.user.AcceptLinkedChild(
+ self.cnxn, self.user_3.user_id, self.user_2.user_id)
+
+ self.SignIn(user_id=self.user_3.user_id)
+ with self.work_env as we:
+ remove_editor_ids = [self.user_2.user_id]
+ we.RemoveHotlistEditors(hotlist.hotlist_id, remove_editor_ids)
+
+ updated_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(updated_hotlist.owner_ids, owner_ids)
+ self.assertEqual(updated_hotlist.editor_ids, [])
+
+ def testDeleteHotlist(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'hotlistName', 'summary', 'desc', [444], [])
+
+ self.SignIn(user_id=444)
+ with self.work_env as we:
+ we.DeleteHotlist(hotlist.hotlist_id)
+
+ # Just test that services.features.ExpungeHotlists was called
+ self.assertTrue(
+ hotlist.hotlist_id in self.services.features.expunged_hotlist_ids)
+
+ def testDeleteHotlist_NoPerms(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'hotlistName', 'summary', 'desc', [444], [])
+
+ self.SignIn(user_id=333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.DeleteHotlist(hotlist.hotlist_id)
+
+ def testListHotlistsByUser_Normal(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[444], editor_ids=[])
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(444)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([444], hotlist.owner_ids)
+ self.assertEqual([], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByUser_AnotherUser(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[333], editor_ids=[])
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(333)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([333], hotlist.owner_ids)
+ self.assertEqual([], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByUser_NotSignedIn(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[444], editor_ids=[])
+
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(444)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([444], hotlist.owner_ids)
+ self.assertEqual([], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByUser_NoUserId(self):
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.ListHotlistsByUser(None)
+
+
+ def testListHotlistsByUser_Empty(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[333], editor_ids=[])
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(444)
+
+ self.assertEqual(0, len(hotlists))
+
+ def testListHotlistsByUser_NoHotlists(self):
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(444)
+
+ self.assertEqual(0, len(hotlists))
+
+ def testListHotlistsByUser_PrivateHotlistAsOwner(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[333], is_private=True)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(333)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([111], hotlist.owner_ids)
+ self.assertEqual([333], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByUser_PrivateHotlistAsEditor(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[333], editor_ids=[111], is_private=True)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(333)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([333], hotlist.owner_ids)
+ self.assertEqual([111], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByUser_PrivateHotlistNoAcess(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[333], editor_ids=[], is_private=True)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByUser(333)
+
+ self.assertEqual(0, len(hotlists))
+
+ def testListHotlistsByIssue_Normal(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist.hotlist_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByIssue(78901)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([111], hotlist.owner_ids)
+ self.assertEqual([], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByIssue_NotSignedIn(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist.hotlist_id)
+
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByIssue(78901)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([111], hotlist.owner_ids)
+ self.assertEqual([], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByIssue_NotAllowedToSeeIssue(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ issue.labels = ['Restrict-View-CoreTeam']
+ self.services.issue.TestAddIssue(issue)
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist.hotlist_id)
+
+ # We should get a permission exception
+ self.SignIn(333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.ListHotlistsByIssue(78901)
+
+ def testListHotlistsByIssue_NoSuchIssue(self):
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchIssueException):
+ with self.work_env as we:
+ we.ListHotlistsByIssue(78901)
+
+ def testListHotlistsByIssue_NoHotlists(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByIssue(78901)
+
+ self.assertEqual(0, len(hotlists))
+
+ def testListHotlistsByIssue_PrivateHotlistAsOwner(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[333], is_private=True)
+ self.AddIssueToHotlist(hotlist.hotlist_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByIssue(78901)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([111], hotlist.owner_ids)
+ self.assertEqual([333], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByIssue_PrivateHotlistAsEditor(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[333], editor_ids=[111], is_private=True)
+ self.AddIssueToHotlist(hotlist.hotlist_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByIssue(78901)
+
+ self.assertEqual(1, len(hotlists))
+ hotlist = hotlists[0]
+ self.assertEqual([333], hotlist.owner_ids)
+ self.assertEqual([111], hotlist.editor_ids)
+ self.assertEqual('Fake-Hotlist', hotlist.name)
+ self.assertEqual('Summary', hotlist.summary)
+ self.assertEqual('Description', hotlist.description)
+
+ def testListHotlistsByIssue_PrivateHotlistNoAcess(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[444], editor_ids=[333], is_private=True)
+ self.AddIssueToHotlist(hotlist.hotlist_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ hotlists = we.ListHotlistsByIssue(78901)
+
+ self.assertEqual(0, len(hotlists))
+
+ def testListRecentlyVisitedHotlists(self):
+ hotlists = [
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[444], editor_ids=[111]),
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[333]),
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Private-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[333], is_private=True),
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Private-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[222], editor_ids=[333], is_private=True)]
+
+ for hotlist in hotlists:
+ self.work_env.services.user.AddVisitedHotlist(
+ self.cnxn, 111, hotlist.hotlist_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ visited_hotlists = we.ListRecentlyVisitedHotlists()
+
+ # We don't have permission to see the last hotlist, because it is marked as
+ # private and we're not owners or editors of it.
+ self.assertEqual(hotlists[:-1], visited_hotlists)
+
+ def testListRecentlyVisitedHotlists_Anon(self):
+ with self.work_env as we:
+ self.assertEqual([], we.ListRecentlyVisitedHotlists())
+
+ def testListStarredHotlists(self):
+ hotlists = [
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[444], editor_ids=[111]),
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[333]),
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Private-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[333], is_private=True),
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Private-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[222], editor_ids=[333], is_private=True)]
+
+ for hotlist in hotlists:
+ self.work_env.services.hotlist_star.SetStar(
+ self.cnxn, hotlist.hotlist_id, 111, True)
+
+ self.SignIn()
+ with self.work_env as we:
+ visited_hotlists = we.ListStarredHotlists()
+
+ # We don't have permission to see the last hotlist, because it is marked as
+ # private and we're not owners or editors of it.
+ self.assertEqual(hotlists[:-1], visited_hotlists)
+
+ def testListStarredHotlists_Anon(self):
+ with self.work_env as we:
+ self.assertEqual([], we.ListStarredHotlists())
+
+ def testStarHotlist_Normal(self):
+ """We can star and unstar a hotlist."""
+ hotlist_id = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[]).hotlist_id
+
+ self.SignIn()
+ with self.work_env as we:
+ self.assertFalse(we.IsHotlistStarred(hotlist_id))
+ we.StarHotlist(hotlist_id, True)
+ self.assertTrue(we.IsHotlistStarred(hotlist_id))
+ we.StarHotlist(hotlist_id, False)
+ self.assertFalse(we.IsHotlistStarred(hotlist_id))
+
+ def testStarHotlist_NoHotlistSpecified(self):
+ """A hotlist must be specified."""
+ self.SignIn()
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.StarHotlist(None, True)
+
+ def testStarHotlist_NoSuchHotlist(self):
+ """We can't star a nonexistent hotlist."""
+ self.SignIn()
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.StarHotlist(999, True)
+
+ def testStarHotlist_Anon(self):
+ """Anon user can't star a hotlist."""
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.StarHotlist(999, True)
+
+ # testIsHotlistStarred_Normal is Tested by method testStarHotlist_Normal().
+
+ def testIsHotlistStarred_Anon(self):
+ """Anon user can't star a hotlist."""
+ with self.work_env as we:
+ self.assertFalse(we.IsHotlistStarred(999))
+
+ def testIsHotlistStarred_NoHotlistSpecified(self):
+ """A Hotlist ID must be specified."""
+ with self.work_env as we:
+ with self.assertRaises(exceptions.InputException):
+ we.IsHotlistStarred(None)
+
+ def testIsHotlistStarred_NoSuchHotlist(self):
+ """We can't check for stars on a nonexistent hotlist."""
+ self.SignIn()
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.IsHotlistStarred(999)
+
+ def testGetHotlistStarCount(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.services.hotlist_star.SetStar(
+ self.cnxn, hotlist.hotlist_id, 111, True)
+ self.services.hotlist_star.SetStar(
+ self.cnxn, hotlist.hotlist_id, 222, True)
+
+ with self.work_env as we:
+ self.assertEqual(2, we.GetHotlistStarCount(hotlist.hotlist_id))
+
+ def testGetHotlistStarCount_NoneHotlist(self):
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.GetHotlistStarCount(None)
+
+ def testGetHotlistStarCount_NoSuchHotlist(self):
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.GetHotlistStarCount(123)
+
+ def testCheckHotlistName_OK(self):
+ self.SignIn()
+ with self.work_env as we:
+ error = we.CheckHotlistName('Fake-Hotlist')
+ self.assertIsNone(error)
+
+ def testCheckHotlistName_Anon(self):
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.CheckHotlistName('Fake-Hotlist')
+
+ def testCheckHotlistName_InvalidName(self):
+ self.SignIn()
+ with self.work_env as we:
+ error = we.CheckHotlistName('**Invalid**')
+ self.assertIsNotNone(error)
+
+ def testCheckHotlistName_AlreadyExists(self):
+ self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ self.SignIn()
+ with self.work_env as we:
+ error = we.CheckHotlistName('Fake-Hotlist')
+ self.assertIsNotNone(error)
+
+ def testRemoveIssuesFromHotlists(self):
+ """We can remove issues from hotlists."""
+ issue1 = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ issue2 = fake.MakeTestIssue(789, 2, 'sum2', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue2)
+
+ hotlist1 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist1.hotlist_id, issue1.issue_id)
+ self.AddIssueToHotlist(hotlist1.hotlist_id, issue2.issue_id)
+
+ hotlist2 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist2.hotlist_id, issue1.issue_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ we.RemoveIssuesFromHotlists(
+ [hotlist1.hotlist_id, hotlist2.hotlist_id], [issue1.issue_id])
+
+ self.assertEqual(
+ [issue2.issue_id], [item.issue_id for item in hotlist1.items])
+ self.assertEqual(0, len(hotlist2.items))
+
+ def testRemoveIssuesFromHotlists_RemoveIssueNotInHotlist(self):
+ """Removing an issue from a hotlist that doesn't have it has no effect."""
+ issue1 = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ issue2 = fake.MakeTestIssue(789, 2, 'sum2', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue2)
+
+ hotlist1 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist1.hotlist_id, issue1.issue_id)
+ self.AddIssueToHotlist(hotlist1.hotlist_id, issue2.issue_id)
+
+ hotlist2 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist2.hotlist_id, issue1.issue_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ # Issue 2 is not in Fake-Hotlist-2
+ we.RemoveIssuesFromHotlists([hotlist2.hotlist_id], [issue2.issue_id])
+
+ self.assertEqual(
+ [issue1.issue_id, issue2.issue_id],
+ [item.issue_id for item in hotlist1.items])
+ self.assertEqual(
+ [issue1.issue_id],
+ [item.issue_id for item in hotlist2.items])
+
+ def testRemoveIssuesFromHotlists_NotAllowed(self):
+ """Only owners and editors can remove issues."""
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ # 333 is not an owner or editor.
+ self.SignIn(333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.RemoveIssuesFromHotlists([hotlist.hotlist_id], [1234])
+
+ def testRemoveIssuesFromHotlists_NoSuchHotlist(self):
+ """We can't remove issues from non existent hotlists."""
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.RemoveIssuesFromHotlists([1, 2, 3], [4, 5, 6])
+
+ def testAddIssuesToHotlists(self):
+ """We can add issues to hotlists."""
+ issue1 = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ issue2 = fake.MakeTestIssue(789, 2, 'sum2', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue2)
+
+ hotlist1 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ hotlist2 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ self.SignIn()
+ with self.work_env as we:
+ we.AddIssuesToHotlists(
+ [hotlist1.hotlist_id, hotlist2.hotlist_id],
+ [issue1.issue_id, issue2.issue_id],
+ 'Foo')
+
+ self.assertEqual(
+ [issue1.issue_id, issue2.issue_id],
+ [item.issue_id for item in hotlist1.items])
+ self.assertEqual(
+ [issue1.issue_id, issue2.issue_id],
+ [item.issue_id for item in hotlist2.items])
+
+ self.assertEqual(['Foo', 'Foo'], [item.note for item in hotlist1.items])
+ self.assertEqual(['Foo', 'Foo'], [item.note for item in hotlist2.items])
+
+ def testAddIssuesToHotlists_IssuesAlreadyInHotlist(self):
+ """Adding an issue to a hotlist that already has it has no effect."""
+ issue1 = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue1)
+ issue2 = fake.MakeTestIssue(789, 2, 'sum2', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue2)
+
+ hotlist1 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist1.hotlist_id, issue1.issue_id)
+ self.AddIssueToHotlist(hotlist1.hotlist_id, issue2.issue_id)
+
+ hotlist2 = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist-2', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist2.hotlist_id, issue1.issue_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ # Issue 1 is in both hotlists
+ we.AddIssuesToHotlists(
+ [hotlist1.hotlist_id, hotlist2.hotlist_id], [issue1.issue_id], None)
+
+ self.assertEqual(
+ [issue1.issue_id, issue2.issue_id],
+ [item.issue_id for item in hotlist1.items])
+ self.assertEqual(
+ [issue1.issue_id],
+ [item.issue_id for item in hotlist2.items])
+
+ def testAddIssuesToHotlists_NotViewable(self):
+ """Users can add viewable issues to hotlists."""
+ issue1 = fake.MakeTestIssue(
+ 789, 1, 'sum1', 'New', 111, issue_id=78901)
+ issue1.labels = ['Restrict-View-CoreTeam']
+ self.services.issue.TestAddIssue(issue1)
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[333], editor_ids=[])
+
+ self.SignIn(user_id=333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.AddIssuesToHotlists([hotlist.hotlist_id], [78901], None)
+
+ def testAddIssuesToHotlists_NotAllowed(self):
+ """Only owners and editors can add issues."""
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ # 333 is not an owner or editor.
+ self.SignIn(user_id=333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.AddIssuesToHotlists([hotlist.hotlist_id], [1234], None)
+
+ def testAddIssuesToHotlists_NoSuchHotlist(self):
+ """We can't remove issues from non existent hotlists."""
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.AddIssuesToHotlists([1, 2, 3], [4, 5, 6], None)
+
+ def createHotlistWithItems(self):
+ issue_1 = fake.MakeTestIssue(789, 1, 'sum', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue_1)
+ issue_2 = fake.MakeTestIssue(789, 2, 'sum', 'New', 111, issue_id=78902)
+ self.services.issue.TestAddIssue(issue_2)
+ issue_3 = fake.MakeTestIssue(789, 3, 'sum', 'New', 111, issue_id=78903)
+ self.services.issue.TestAddIssue(issue_3)
+ issue_4 = fake.MakeTestIssue(789, 4, 'sum', 'New', 111, issue_id=78904)
+ self.services.issue.TestAddIssue(issue_4)
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ hotlist_items = [
+ (issue_4.issue_id, 31, self.user_3.user_id, self.PAST_TIME, ''),
+ (issue_3.issue_id, 21, self.user_1.user_id, self.PAST_TIME, ''),
+ (issue_2.issue_id, 11, self.user_2.user_id, self.PAST_TIME, ''),
+ (issue_1.issue_id, 1, self.user_1.user_id, self.PAST_TIME, '')
+ ]
+ return self.work_env.services.features.TestAddHotlist(
+ 'HotlistName', owner_ids=owner_ids, editor_ids=editor_ids,
+ hotlist_item_fields=hotlist_items)
+
+ def testRemoveHotlistItems(self):
+ """We can remove issues from a hotlist."""
+ hotlist = self.createHotlistWithItems()
+ self.SignIn(self.user_2.user_id)
+ with self.work_env as we:
+ we.RemoveHotlistItems(hotlist.hotlist_id, [78901, 78903])
+
+ self.assertEqual([item.issue_id for item in hotlist.items], [78902, 78904])
+
+ def testRemoveHotlistItems_NoHotlistPermissions(self):
+ """We raise an exception if user lacks edit permissions in hotlist."""
+ self.SignIn(self.user_3.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.RemoveHotlistItems(self.hotlist.hotlist_id, [78901])
+
+ def testRemoveHotlistItems_NoSuchHotlist(self):
+ """We raise an exception if the hotlist is not found."""
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.RemoveHotlistItems(self.dne_hotlist_id, [78901])
+
+ def testRemoveHotlistItems_ItemNotFound(self):
+ """We raise an exception if user tries to remove item not in hotlist."""
+ hotlist = self.createHotlistWithItems()
+ self.SignIn(self.user_2.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.RemoveHotlistItems(hotlist.hotlist_id, [404])
+
+ def testAddHotlistItems_NoSuchHotlist(self):
+ """We raise an exception if the hotlist is not found."""
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.AddHotlistItems(self.dne_hotlist_id, [78901], 0)
+
+ def testAddHotlistItems_NoHotlistEditPermissions(self):
+ """We raise an exception if the user lacks edit permissions in hotlist."""
+ self.SignIn(self.user_3.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.AddHotlistItems(self.hotlist.hotlist_id, [78901], 0)
+
+ def testAddHotlistItems_NoItemsGiven(self):
+ """We raise an exception if the given list of issues is empty."""
+ hotlist = self.createHotlistWithItems()
+ self.SignIn(self.user_2.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.AddHotlistItems(hotlist.hotlist_id, [], 0)
+
+ def testAddHotlistItems(self):
+ """We add new items to the hotlist and don't touch existing items."""
+ hotlist = self.createHotlistWithItems()
+ self.SignIn(self.user_2.user_id)
+ with self.work_env as we:
+ we.AddHotlistItems(hotlist.hotlist_id, [78909, 78910, 78901], 2)
+
+ expected_item_ids = [78901, 78902, 78909, 78910, 78903, 78904]
+ updated_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(
+ expected_item_ids, [item.issue_id for item in updated_hotlist.items])
+
+ def testRerankHotlistItems_NoPerms(self):
+ """We don't let non editors/owners rerank HotlistItems."""
+ hotlist = self.createHotlistWithItems()
+ moved_ids = [78901]
+ target_position = 0
+ self.SignIn(self.user_3.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.RerankHotlistItems(hotlist.hotlist_id, moved_ids, target_position)
+
+ def testRerankHotlistItems_HotlistItemsNotFound(self):
+ """We raise an exception if not all Issue IDs are in the hotlist."""
+ hotlist = self.createHotlistWithItems()
+ # 78909 is not an existing HotlistItem issue.
+ moved_ids = [78901, 78909]
+ target_position = 1
+ self.SignIn(self.user_2.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.RerankHotlistItems(hotlist.hotlist_id, moved_ids, target_position)
+
+ def testRerankHotlistItems_MovedIssuesEmpty(self):
+ """We raise an exception if the list of Issue IDs is empty."""
+ hotlist = self.createHotlistWithItems()
+ moved_ids = []
+ target_position = 1
+ self.SignIn(self.user_2.user_id)
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.RerankHotlistItems(hotlist.hotlist_id, moved_ids, target_position)
+
+ @mock.patch('time.time')
+ def testRerankHotlistItems(self, fake_time):
+ """We can rerank HotlistItems."""
+ fake_time.return_value = self.PAST_TIME
+ hotlist = self.createHotlistWithItems()
+ moved_ids = [78901, 78903]
+ target_position = 1
+ self.SignIn(self.user_2.user_id)
+ with self.work_env as we:
+ updated_hotlist = we.RerankHotlistItems(
+ hotlist.hotlist_id, moved_ids, target_position)
+
+ expected_item_ids = [78902, 78901, 78903, 78904]
+ self.assertEqual(
+ expected_item_ids, [item.issue_id for item in updated_hotlist.items])
+
+ @mock.patch('time.time')
+ def testGetChangedHotlistItems(self, fake_time):
+ """We can get changed HotlistItems when moving existing and new issues."""
+ fake_time.return_value = self.PAST_TIME
+ hotlist = self.createHotlistWithItems()
+ # moved_ids include new issues not in hotlist: [78907, 78909]
+ moved_ids = [78901, 78907, 78903, 78909]
+ target_position = 1
+ self.SignIn(self.user_2.user_id)
+ with self.work_env as we:
+ changed_items = we._GetChangedHotlistItems(
+ hotlist, moved_ids, target_position)
+
+ expected_hotlist_items = [
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=78901,
+ rank=14,
+ note='',
+ adder_id=self.user_1.user_id,
+ date_added=self.PAST_TIME),
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=78907,
+ rank=19,
+ adder_id=self.user_2.user_id,
+ date_added=self.PAST_TIME),
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=78903,
+ rank=24,
+ note='',
+ adder_id=self.user_1.user_id,
+ date_added=self.PAST_TIME),
+ features_pb2.Hotlist.HotlistItem(
+ issue_id=78909,
+ rank=29,
+ adder_id=self.user_2.user_id,
+ date_added=self.PAST_TIME)
+ ]
+ self.assertEqual(changed_items, expected_hotlist_items)
+
+ # TODO(crbug/monorail/7104): Remove these tests once RerankHotlistIssues
+ # is deleted.
+ def testRerankHotlistIssues_SplitAbove(self):
+ """We can rerank issues in a hotlist with split_above = true."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ follower_ids = []
+ hotlist_items = [
+ (78904, 31, self.user_2.user_id, self.PAST_TIME, 'note'),
+ (78903, 21, self.user_2.user_id, self.PAST_TIME, 'note'),
+ (78902, 11, self.user_2.user_id, self.PAST_TIME, 'note'),
+ (78901, 1, self.user_2.user_id, self.PAST_TIME, 'note')]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'HotlistName', summary='summary', owner_ids=owner_ids,
+ editor_ids=editor_ids, follower_ids=follower_ids,
+ hotlist_id=1235, hotlist_item_fields=hotlist_items)
+
+ moved_ids = [78901]
+ target_id = 78904
+ split_above = True
+ self.SignIn(self.user_2.user_id)
+ with self.work_env as we:
+ we.RerankHotlistIssues(
+ hotlist.hotlist_id, moved_ids, target_id, split_above)
+ updated_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(
+ [item.issue_id for item in updated_hotlist.items],
+ [78902, 78903, 78901, 78904])
+
+ def testRerankHotlistIssues_SplitBelow(self):
+ """We can rerank issues in a hotlist with split_above = false."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = [self.user_2.user_id]
+ follower_ids = []
+ hotlist_items = [
+ (78904, 31, self.user_2.user_id, self.PAST_TIME, 'note'),
+ (78903, 21, self.user_2.user_id, self.PAST_TIME, 'note'),
+ (78902, 11, self.user_2.user_id, self.PAST_TIME, 'note'),
+ (78901, 1, self.user_2.user_id, self.PAST_TIME, 'note')]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'HotlistName', summary='summary', owner_ids=owner_ids,
+ editor_ids=editor_ids, follower_ids=follower_ids,
+ hotlist_id=1235, hotlist_item_fields=hotlist_items)
+
+ moved_ids = [78901]
+ target_id = 78904
+ split_above = False
+ self.SignIn(self.user_2.user_id)
+ with self.work_env as we:
+ we.RerankHotlistIssues(
+ hotlist.hotlist_id, moved_ids, target_id, split_above)
+ updated_hotlist = we.GetHotlist(hotlist.hotlist_id)
+ self.assertEqual(
+ [item.issue_id for item in updated_hotlist.items],
+ [78902, 78903, 78904, 78901])
+
+ def testRerankHotlistIssues_NoPerms(self):
+ """We don't let non editors/owners update issue ranks."""
+ owner_ids = [self.user_1.user_id]
+ editor_ids = []
+ follower_ids = [self.user_3.user_id]
+ hotlist = self.work_env.services.features.TestAddHotlist(
+ 'HotlistName', summary='summary', owner_ids=owner_ids,
+ editor_ids=editor_ids, follower_ids=follower_ids,
+ hotlist_id=1235)
+
+ moved_ids = [78901]
+ target_id = 78904
+ split_above = True
+ self.SignIn(self.user_3.user_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.RerankHotlistIssues(
+ hotlist.hotlist_id, moved_ids, target_id, split_above)
+
+ def testUpdateHotlistIssueNote(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+ self.AddIssueToHotlist(hotlist.hotlist_id, issue.issue_id)
+
+ self.SignIn()
+ with self.work_env as we:
+ we.UpdateHotlistIssueNote(hotlist.hotlist_id, 78901, 'Note')
+
+ self.assertEqual('Note', hotlist.items[0].note)
+
+ def testUpdateHotlistIssueNote_IssueNotInHotlist(self):
+ issue = fake.MakeTestIssue(789, 1, 'sum1', 'New', 111, issue_id=78901)
+ self.services.issue.TestAddIssue(issue)
+
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ self.SignIn()
+ with self.assertRaises(exceptions.InputException):
+ with self.work_env as we:
+ we.UpdateHotlistIssueNote(hotlist.hotlist_id, 78901, 'Note')
+
+ def testUpdateHotlistIssueNote_NoSuchIssue(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ self.SignIn()
+ with self.assertRaises(exceptions.NoSuchIssueException):
+ with self.work_env as we:
+ we.UpdateHotlistIssueNote(hotlist.hotlist_id, 78901, 'Note')
+
+ def testUpdateHotlistIssueNote_CantEditHotlist(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[111], editor_ids=[])
+
+ self.SignIn(user_id=333)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.UpdateHotlistIssueNote(hotlist.hotlist_id, 78901, 'Note')
+
+ def testUpdateHotlistIssueNote_NoSuchHotlist(self):
+ self.SignIn()
+ with self.assertRaises(features_svc.NoSuchHotlistException):
+ with self.work_env as we:
+ we.UpdateHotlistIssueNote(1234, 78901, 'Note')
+
+ def testListHotlistPermissions_Anon(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[self.user_1.user_id], editor_ids=[])
+ # Anon can view public hotlist.
+ with self.work_env as we:
+ anon_perms = we.ListHotlistPermissions(hotlist.hotlist_id)
+ self.assertEqual(anon_perms, [])
+
+ # Anon cannot view private hotlist.
+ hotlist.is_private = True
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.ListHotlistPermissions(hotlist.hotlist_id)
+
+ def testListHotlistPermissions_Owner(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[self.user_1.user_id], editor_ids=[])
+
+ self.SignIn(user_id=self.user_1.user_id)
+ with self.work_env as we:
+ owner_perms = we.ListHotlistPermissions(hotlist.hotlist_id)
+ self.assertEqual(owner_perms, permissions.HOTLIST_OWNER_PERMISSIONS)
+
+ def testListHotlistPermissions_Editor(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[self.user_1.user_id], editor_ids=[self.user_2.user_id])
+
+ self.SignIn(user_id=self.user_2.user_id)
+ with self.work_env as we:
+ owner_perms = we.ListHotlistPermissions(hotlist.hotlist_id)
+ self.assertEqual(owner_perms, permissions.HOTLIST_EDITOR_PERMISSIONS)
+
+ def testListHotlistPermissions_NonMember(self):
+ hotlist = self.work_env.services.features.CreateHotlist(
+ self.cnxn, 'Fake-Hotlist', 'Summary', 'Description',
+ owner_ids=[self.user_1.user_id], editor_ids=[self.user_2.user_id])
+
+ self.SignIn(user_id=self.user_3.user_id)
+ with self.work_env as we:
+ perms = we.ListHotlistPermissions(hotlist.hotlist_id)
+ self.assertEqual(perms, [])
+
+ hotlist.is_private = True
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ we.ListHotlistPermissions(hotlist.hotlist_id)
+
+ def testListFieldDefPermissions_Anon(self):
+ field_id = self.services.config.CreateFieldDef(
+ self.cnxn, self.project.project_id, 'Field', 'STR_TYPE', None, None,
+ None, None, None, None, None, None, None, None, None, None, None, None,
+ [], [])
+ restricted_field_id = self.services.config.CreateFieldDef(
+ self.cnxn,
+ self.project.project_id,
+ 'ResField',
+ 'STR_TYPE',
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None, [], [],
+ is_restricted_field=True)
+
+ # Anon can only view fields in a public project.
+ with self.work_env as we:
+ anon_perms = we.ListFieldDefPermissions(field_id, self.project.project_id)
+ self.assertEqual(anon_perms, [])
+ with self.work_env as we:
+ anon_perms = we.ListFieldDefPermissions(
+ restricted_field_id, self.project.project_id)
+ self.assertEqual(anon_perms, [])
+
+ # Anon cannot view fields in a private project.
+ self.project.access = project_pb2.ProjectAccess.MEMBERS_ONLY
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ anon_perms = we.ListFieldDefPermissions(
+ field_id, self.project.project_id)
+ with self.assertRaises(permissions.PermissionException):
+ with self.work_env as we:
+ anon_perms = we.ListFieldDefPermissions(
+ restricted_field_id, self.project.project_id)
+
+ def testListFieldDefPermissions_SiteAdminAndProjectOwners(self):
+ """SiteAdmins/ProjectOwners can always edit a field and its value."""
+ field_id = self.services.config.CreateFieldDef(
+ self.cnxn, self.project.project_id, 'Field', 'STR_TYPE', None, None,
+ None, None, None, None, None, None, None, None, None, None, None, None,
+ [], [])
+ restricted_field_id = self.services.config.CreateFieldDef(
+ self.cnxn,
+ self.project.project_id,
+ 'ResField',
+ 'STR_TYPE',
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None, [], [],
+ is_restricted_field=True)
+
+ self.SignIn(user_id=self.admin_user.user_id)
+
+ with self.work_env as we:
+ site_admin_perms_1 = we.ListFieldDefPermissions(
+ field_id, self.project.project_id)
+ self.assertEqual(
+ site_admin_perms_1,
+ [permissions.EDIT_FIELD_DEF, permissions.EDIT_FIELD_DEF_VALUE])
+
+ with self.work_env as we:
+ site_admin_perms_2 = we.ListFieldDefPermissions(
+ restricted_field_id, self.project.project_id)
+ self.assertEqual(
+ site_admin_perms_2,
+ [permissions.EDIT_FIELD_DEF, permissions.EDIT_FIELD_DEF_VALUE])
+
+ def testListFieldDefPermissions_FieldEditor(self):
+ """Field Editors can edit the value of a field."""
+ field_id = self.services.config.CreateFieldDef(
+ self.cnxn, self.project.project_id, 'Field', 'STR_TYPE', None, None,
+ None, None, None, None, None, None, None, None, None, None, None, None,
+ [], [111])
+ restricted_field_id = self.services.config.CreateFieldDef(
+ self.cnxn,
+ self.project.project_id,
+ 'ResField',
+ 'STR_TYPE',
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None,
+ None, [], [111],
+ is_restricted_field=True)
+
+ self.SignIn(user_id=self.user_1.user_id)
+
+ with self.work_env as we:
+ field_editor_perms = we.ListFieldDefPermissions(
+ field_id, self.project.project_id)
+ self.assertEqual(field_editor_perms, [permissions.EDIT_FIELD_DEF_VALUE])
+
+ with self.work_env as we:
+ field_editor_perms = we.ListFieldDefPermissions(
+ restricted_field_id, self.project.project_id)
+ self.assertEqual(field_editor_perms, [permissions.EDIT_FIELD_DEF_VALUE])
+
+
+ # FUTURE: UpdateHotlist()
+ # FUTURE: DeleteHotlist()
+
+ def setUpExpungeUsersFromStars(self):
+ config = fake.MakeTestConfig(789, [], [])
+ self.work_env.services.project_star.SetStarsBatch(
+ self.cnxn, 789, [222, 444, 555], True)
+ self.work_env.services.issue_star.SetStarsBatch(
+ self.cnxn, self.services, config, 78901, [222, 444, 666], True)
+ self.work_env.services.hotlist_star.SetStarsBatch(
+ self.cnxn, 1678, [222, 444, 555], True)
+ self.work_env.services.user_star.SetStarsBatch(
+ self.cnxn, 888, [222, 333, 777], True)
+ self.work_env.services.user_star.SetStarsBatch(
+ self.cnxn, 999, [111, 222, 333], True)
+
+ def testExpungeUsersFromStars(self):
+ self.setUpExpungeUsersFromStars()
+ user_ids = [999, 222, 555]
+ self.work_env.expungeUsersFromStars(user_ids)
+ self.assertEqual(
+ self.work_env.services.project_star.LookupItemStarrers(self.cnxn, 789),
+ [444])
+ self.assertEqual(
+ self.work_env.services.issue_star.LookupItemStarrers(self.cnxn, 78901),
+ [444, 666])
+ self.assertEqual(
+ self.work_env.services.hotlist_star.LookupItemStarrers(self.cnxn, 1678),
+ [444])
+ self.assertEqual(
+ self.work_env.services.user_star.LookupItemStarrers(self.cnxn, 888),
+ [333, 777])
+ self.assertEqual(
+ self.work_env.services.user_star.expunged_item_ids, [999, 222, 555])