def __init__(self,
services,
cnxn=None,
requester=None,
auth=None,
perms=None,
autocreate=True):
"""Construct a MonorailContext.
Args:
services: Connection to backends.
cnxn: Optional connection to SQL database.
requester: String email address of user making the request or None.
auth: AuthData object used during testing.
perms: PermissionSet used during testing.
autocreate: Set to False to require that a row in the User table already
exists for this user, otherwise raise NoSuchUserException.
"""
self.cnxn = cnxn or sql.MonorailConnection()
self.auth = auth or authdata.AuthData.FromEmail(
self.cnxn, requester, services, autocreate=autocreate)
self.perms = perms # Usually None until LookupLoggedInUserPerms() called.
self.profiler = profiler.Profiler()
# TODO(jrobbins): make self.errors not be UI-centric.
self.warnings = []
self.errors = template_helpers.EZTError()
def testParseRules(self):
cnxn = 'fake SQL connection'
post_data = {
'predicate1': 'a, b c',
'action_type1': 'default_status',
'action_value1': 'Reviewed',
'predicate2': 'a, b c',
'action_type2': 'default_owner',
'action_value2': 'jrobbins',
'predicate3': 'a, b c',
'action_type3': 'add_ccs',
'action_value3': 'jrobbins, mike.j.parent',
'predicate4': 'a, b c',
'action_type4': 'add_labels',
'action_value4': 'hot, cold',
}
errors = template_helpers.EZTError()
rules = filterrules_helpers.ParseRules(cnxn, post_data,
self.services.user, errors)
self.assertEquals(rules[0].predicate, 'a, b c')
self.assertEquals(rules[0].default_status, 'Reviewed')
self.assertEquals(rules[1].default_owner_id, TEST_ID_MAP['jrobbins'])
self.assertEquals(rules[2].add_cc_ids[0], TEST_ID_MAP['jrobbins'])
self.assertEquals(rules[2].add_cc_ids[1], TEST_ID_MAP['mike.j.parent'])
self.assertEquals(rules[3].add_labels[0], 'hot')
self.assertEquals(rules[3].add_labels[1], 'cold')
self.assertEquals(len(rules), 4)
self.assertFalse(errors.AnyErrors())
def setUp(self):
self.config = tracker_bizobj.MakeDefaultProjectIssueConfig(789)
self.services = service_manager.Services(user=fake.UserService())
self.mr = testing_helpers.MakeMonorailRequest(project=fake.Project(),
services=self.services)
self.mr.cnxn = fake.MonorailConnection()
self.errors = template_helpers.EZTError()
def testEZTError(self):
errors = template_helpers.EZTError()
self.assertFalse(errors.AnyErrors())
errors.error_a = 'A'
self.assertTrue(errors.AnyErrors())
self.assertEquals('A', errors.error_a)
errors.SetError('error_b', 'B')
self.assertTrue(errors.AnyErrors())
self.assertEquals('A', errors.error_a)
self.assertEquals('B', errors.error_b)
def __init__(self, request, services, perms=None):
self.cnxn = None
self.auth = monorailrequest.AuthData.FromEmail(
self.cnxn, request['requester'], services)
self.me_user_id = self.auth.user_id
self.project_name = None
self.project = None
self.viewed_username = None
self.viewed_user_auth = None
self.config = None
if 'userId' in request:
self.viewed_username = request['userId']
self.viewed_user_auth = monorailrequest.AuthData.FromEmail(
self.cnxn, self.viewed_username, services)
elif 'groupName' in request:
self.viewed_username = request['groupName']
try:
self.viewed_user_auth = monorailrequest.AuthData.FromEmail(
self.cnxn, self.viewed_username, services)
except user_svc.NoSuchUserException:
self.viewed_user_auth = None
if 'projectId' in request:
self.project_name = request['projectId']
self.project = services.project.GetProjectByName(
self.cnxn, self.project_name)
self.config = services.config.GetProjectConfig(
self.cnxn, self.project_id)
self.perms = perms or permissions.GetPermissions(
self.auth.user_pb, self.auth.effective_ids, self.project)
self.granted_perms = set()
self.params = {
'can': request.get('can', 1),
'start': request.get('startIndex', 0),
'num': request.get('maxResults', 100),
'q': request.get('q', ''),
'sort': request.get('sort', ''),
'groupby': '',
'projects': request.get('additionalProject', []) + [self.project_name]}
self.use_cached_searches = True
self.errors = template_helpers.EZTError()
self.mode = None
self.query_project_names = self.GetParam('projects')
self.group_by_spec = self.GetParam('groupby')
self.sort_spec = self.GetParam('sort')
self.query = self.GetParam('q')
self.can = self.GetParam('can')
self.start = self.GetParam('start')
self.num = self.GetParam('num')
def setUp(self):
self.config = tracker_bizobj.MakeDefaultProjectIssueConfig(789)
self.config.well_known_labels.append(
tracker_pb2.LabelDef(label='OldLabel',
label_docstring='Do not use any longer',
deprecated=True))
self.services = service_manager.Services(
usergroup=fake.UserGroupService(),
config=fake.ConfigService(),
user=fake.UserService())
self.mr = testing_helpers.MakeMonorailRequest(project=fake.Project(),
services=self.services)
self.mr.cnxn = fake.MonorailConnection()
self.errors = template_helpers.EZTError()
def __init__(self, params=None):
"""Initialize the MonorailRequest object."""
self.form_overrides = {}
if params:
self.form_overrides.update(params)
self.warnings = []
self.errors = template_helpers.EZTError()
self.debug_enabled = False
self.use_cached_searches = True
self.cnxn = sql.MonorailConnection()
self.auth = AuthData() # Authentication info for logged-in user
self.project_name = None
self.project = None
self.config = None
self.hotlist_id = None
self.hotlist = None
self.hotlist_name = None
self.viewed_username = None
self.viewed_user_auth = AuthData()
def __init__(self, request, services):
requester = (endpoints.get_current_user() or oauth.get_current_user(
framework_constants.OAUTH_SCOPE))
requester_email = requester.email().lower()
self.cnxn = sql.MonorailConnection()
self.auth = AuthData.FromEmail(self.cnxn, requester_email, services)
self.me_user_id = self.auth.user_id
self.viewed_username = None
self.viewed_user_auth = None
self.project_name = None
self.project = None
self.issue = None
self.config = None
self.granted_perms = set()
# query parameters
self.params = {
'can': 1,
'start': 0,
'num': 100,
'q': '',
'sort': '',
'groupby': '',
'projects': [],
'hotlists': []
}
self.use_cached_searches = True
self.warnings = []
self.errors = template_helpers.EZTError()
self.mode = None
if hasattr(request, 'projectId'):
self.project_name = request.projectId
self.project = services.project.GetProjectByName(
self.cnxn, self.project_name)
self.params['projects'].append(self.project_name)
self.config = services.config.GetProjectConfig(
self.cnxn, self.project_id)
if hasattr(request, 'additionalProject'):
self.params['projects'].extend(request.additionalProject)
self.params['projects'] = list(set(self.params['projects']))
if hasattr(request, 'issueId'):
self.issue = services.issue.GetIssueByLocalID(
self.cnxn, self.project_id, request.issueId)
self.granted_perms = tracker_bizobj.GetGrantedPerms(
self.issue, self.auth.effective_ids, self.config)
if hasattr(request, 'userId'):
self.viewed_username = request.userId.lower()
if self.viewed_username == 'me':
self.viewed_username = requester_email
self.viewed_user_auth = AuthData.FromEmail(self.cnxn,
self.viewed_username,
services)
elif hasattr(request, 'groupName'):
self.viewed_username = request.groupName.lower()
try:
self.viewed_user_auth = AuthData.FromEmail(
self.cnxn, self.viewed_username, services)
except user_svc.NoSuchUserException:
self.viewed_user_auth = None
self.perms = permissions.GetPermissions(self.auth.user_pb,
self.auth.effective_ids,
self.project)
# Build q.
if hasattr(request, 'q') and request.q:
self.params['q'] = request.q
if hasattr(request, 'publishedMax') and request.publishedMax:
self.params['q'] += ' opened<=%d' % request.publishedMax
if hasattr(request, 'publishedMin') and request.publishedMin:
self.params['q'] += ' opened>=%d' % request.publishedMin
if hasattr(request, 'updatedMax') and request.updatedMax:
self.params['q'] += ' modified<=%d' % request.updatedMax
if hasattr(request, 'updatedMin') and request.updatedMin:
self.params['q'] += ' modified>=%d' % request.updatedMin
if hasattr(request, 'owner') and request.owner:
self.params['q'] += ' owner:%s' % request.owner
if hasattr(request, 'status') and request.status:
self.params['q'] += ' status:%s' % request.status
if hasattr(request, 'label') and request.label:
self.params['q'] += ' label:%s' % request.label
if hasattr(request, 'can') and request.can:
if request.can == api_pb2_v1.CannedQuery.all:
self.params['can'] = 1
elif request.can == api_pb2_v1.CannedQuery.new:
self.params['can'] = 6
elif request.can == api_pb2_v1.CannedQuery.open:
self.params['can'] = 2
elif request.can == api_pb2_v1.CannedQuery.owned:
self.params['can'] = 3
elif request.can == api_pb2_v1.CannedQuery.reported:
self.params['can'] = 4
elif request.can == api_pb2_v1.CannedQuery.starred:
self.params['can'] = 5
elif request.can == api_pb2_v1.CannedQuery.to_verify:
self.params['can'] = 7
else: # Endpoints should have caught this.
raise InputException('Canned query %s is not supported.',
request.can)
if hasattr(request, 'startIndex') and request.startIndex:
self.params['start'] = request.startIndex
if hasattr(request, 'maxResults') and request.maxResults:
self.params['num'] = request.maxResults
if hasattr(request, 'sort') and request.sort:
self.params['sort'] = request.sort
self.query_project_names = self.GetParam('projects')
self.group_by_spec = self.GetParam('groupby')
self.sort_spec = self.GetParam('sort')
self.query = self.GetParam('q')
self.can = self.GetParam('can')
self.start = self.GetParam('start')
self.num = self.GetParam('num')
def testParseRulesNone(self):
cnxn = 'fake SQL connection'
post_data = {}
rules = filterrules_helpers.ParseRules(cnxn, post_data, None,
template_helpers.EZTError())
self.assertEquals(rules, [])
