def test_domain_with_job_and_fuzzer(self):
"""Test domain user with job and fuzzer."""
self.mock.has_access.side_effect = _has_access
self.mock.get_user_job_type.return_value = 'job'
self.mock._allowed_entities_for_user.side_effect = [['job2'], ['fuzzer']]
self.mock.get_permission_names.side_effect = [['perm'], ['perm1']]
crash_access.add_scope(self.query, self.params, 'security_flag', 'job_type',
'fuzzer_name')
self.assertTrue(self.params['permissions']['everything'])
self.assertFalse(self.params['permissions']['isPrivileged'])
self.assertListEqual(['perm', 'job'], self.params['permissions']['jobs'])
self.assertListEqual(['perm1'], self.params['permissions']['fuzzers'])
self.query.union.assert_has_calls([])
self.query.union.assert_called_once_with(mock.ANY, mock.ANY, mock.ANY)
everything_query = self.query.union.call_args[0][0]
job_query = self.query.union.call_args[0][1]
fuzzer_query = self.query.union.call_args[0][2]
everything_query.union.assert_has_calls([])
job_query.union.assert_has_calls([])
fuzzer_query.union.assert_has_calls([])
everything_query.filter.assert_has_calls(
[mock.call('security_flag', False)])
job_query.filter_in.assert_has_calls([
mock.call('job_type', ['job2', 'job']),
])
fuzzer_query.filter_in.assert_has_calls([
mock.call('fuzzer_name', ['fuzzer']),
])
def get_result():
"""Get the result for the crash stats page."""
params = dict(request.iterparams())
params['type'] = params.get('type', 'regression')
page = helpers.cast(request.get('page') or 1, int, "'page' is not an int.")
is_revision_empty = 'revision' not in params
query = big_query_query.Query()
crash_access.add_scope(query, params, 'security_flag', 'job_type',
'fuzzer_name')
if is_revision_empty:
total_count = 0
rows = []
else:
filters.add(query, params, FILTERS)
rows, total_count = get(
params=params,
query=query,
offset=(page - 1) * PAGE_SIZE,
limit=PAGE_SIZE)
helpers.log('Regression', helpers.VIEW_OPERATION)
result = {
'totalPages': (total_count // PAGE_SIZE) + 1,
'page': page,
'pageSize': PAGE_SIZE,
'items': rows,
'totalCount': total_count,
'isRevisionEmpty': is_revision_empty
}
return result, params
def test_default_global_privileged(self):
"""Test the default filter for globally privileged users."""
self.mock.has_access.return_value = True
crash_access.add_scope(self.query, self.params, 'security_flag', 'job_type',
'fuzzer_name')
self.assertTrue(self.params['permissions']['everything'])
self.assertTrue(self.params['permissions']['isPrivileged'])
self.assertEqual([], self.params['permissions']['jobs'])
self.assertFalse([], self.params['permissions']['fuzzers'])
self.query.union.assert_has_calls([])
self.query.filter.assert_has_calls([])
def test_default_domain(self):
"""Test the default filter for domain users."""
self.mock.has_access.side_effect = _has_access
crash_access.add_scope(self.query, self.params, 'security_flag', 'job_type',
'fuzzer_name')
self.assertTrue(self.params['permissions']['everything'])
self.assertFalse(self.params['permissions']['isPrivileged'])
self.assertEqual([], self.params['permissions']['jobs'])
self.assertFalse([], self.params['permissions']['fuzzers'])
self.query.filter.assert_has_calls([])
self.query.union.assert_called_once_with(mock.ANY)
q = self.query.union.call_args[0][0]
q.union.assert_has_calls([])
q.filter.assert_has_calls([mock.call('security_flag', False)])
def get_result():
"""Get the result for the crash stats page."""
params = dict(request.iterparams())
page = helpers.cast(request.get('page') or 1, int, "'page' is not an int.")
group_by = params.get('group', 'platform')
params['group'] = group_by
sort_by = params.get('sort', 'total_count')
params['sort'] = sort_by
params['number'] = params.get('number', 'count')
# Conditions for individual records.
query = crash_stats.Query()
query.group_by = group_by
query.sort_by = sort_by
crash_access.add_scope(query, params, 'security_flag', 'job_type',
'fuzzer_name')
filters.add(query, params, FILTERS)
# Conditions after grouping.
group_query = crash_stats.Query()
filters.add(group_query, params, GROUP_FILTERS)
try:
total_count, rows = crash_stats.get(
query=query,
group_query=group_query,
offset=(page - 1) * PAGE_SIZE,
limit=PAGE_SIZE)
except ValueError:
raise helpers.EarlyExitException('Invalid filters', 400)
attach_testcases(rows)
helpers.log('CrashStats', helpers.VIEW_OPERATION)
result = {
'totalPages': (total_count // PAGE_SIZE) + 1,
'page': page,
'pageSize': PAGE_SIZE,
'items': rows,
'totalCount': total_count
}
return result, params
def get_result(this):
"""Get the result for the testcase list page."""
params = {k: v for k, v in this.request.iterparams()}
page = helpers.cast(
this.request.get('page') or 1, int, "'page' is not an int.")
query = datastore_query.Query(data_types.Testcase)
crash_access.add_scope(query, params, 'security_flag', 'job_type',
'fuzzer_name_indices')
add_filters(query, params)
testcases, total_pages, total_items, has_more = query.fetch_page(
page=page,
page_size=PAGE_SIZE,
projection=FIELDS,
more_limit=MORE_LIMIT)
items = []
for testcase in testcases:
regression_range = ''
fixed_range = ''
if testcase.regression and testcase.regression != 'NA':
regression_range = testcase.regression
if testcase.fixed and testcase.fixed != 'NA':
fixed_range = testcase.fixed
item = {
'id': testcase.key.id(),
'crashType': ' '.join(testcase.crash_type.splitlines()),
'crashStateLines': testcase.crash_state.strip().splitlines(),
'jobType': testcase.job_type,
'isClosed': not testcase.open,
'isFixed': testcase.fixed and testcase.fixed != 'NA',
'isReproducible': not testcase.one_time_crasher_flag,
'isSecurity': testcase.security_flag,
'isImpactSet': testcase.is_impact_set_flag,
'impacts': {
'stable': testcase.impact_stable_version,
'beta': testcase.impact_beta_version,
},
'regressionRange': regression_range,
'fixedRange': fixed_range,
'groupId': testcase.group_id,
'projectName': testcase.project_name,
'platform': testcase.platform,
'issueId': testcase.bug_information
or testcase.group_bug_information,
'showImpacts': testcase.has_impacts(),
'impactsProduction': testcase.impacts_production()
}
if testcase.timestamp:
item['timestamp'] = utils.utc_datetime_to_timestamp(
testcase.timestamp)
items.append(item)
helpers.log('Testcases', helpers.VIEW_OPERATION)
result = {
'hasMore': has_more,
'items': items,
'page': page,
'pageSize': PAGE_SIZE,
'totalItems': total_items,
'totalPages': total_pages,
}
return result, params
def test_forbidden(self):
"""Test when user is forbidden."""
self.mock.has_access.return_value = False
with self.assertRaises(helpers.EarlyExitException):
crash_access.add_scope(self.query, self.params, 'security_flag',
'job_type', 'fuzzer_name')
