def testGatherHelpData_SignedIn(self):
servlet = issuedetail.IssueDetail('req', 'res', services=self.services)
mr = testing_helpers.MakeMonorailRequest()
mr.auth.user_id = 111L
# User needs to click through the privacy dialog.
help_data = servlet.GatherHelpData(mr, {})
self.assertEqual('privacy_click_through', help_data['cue'])
mr.auth.user_pb.dismissed_cues = ['privacy_click_through']
# User did not jump to an issue, no query at all.
help_data = servlet.GatherHelpData(mr, {})
self.assertEqual(None, help_data['cue'])
# User did not jump to an issue, query was not a local ID number.
mr.query = 'memory leak'
help_data = servlet.GatherHelpData(mr, {})
self.assertEqual(None, help_data['cue'])
# User jumped directly to an issue, maybe they meant to search instead.
mr.query = '123'
help_data = servlet.GatherHelpData(mr, {})
self.assertEqual('search_for_numbers', help_data['cue'])
self.assertEqual(123, help_data['jump_local_id'])
# User is viewing an issue with an unavailable owner.
mr.query = ''
issue_view = testing_helpers.Blank(
is_spam=False,
owner=testing_helpers.Blank(user_id=111L,
avail_message='On vacation'),
derived_owner=testing_helpers.Blank(user_id=0L, avail_message=''),
cc=[testing_helpers.Blank(user_id=222L, avail_message='')],
derived_cc=[testing_helpers.Blank(user_id=333L, avail_message='')])
def testHandleBackendSearchResponse_TriggersRetry(self):
response_str = None
rpc = testing_helpers.Blank(
get_result=lambda: testing_helpers.Blank(content=response_str))
rpc_tuple = (NOW, 2, rpc)
rpc_tuples = [] # New RPC should be appended here
filtered_iids = {} # No change here until retry completes.
search_limit_reached = {} # No change here until retry completes.
processed_invalidations_up_to = 12345
error_responses = set()
mr = testing_helpers.MakeMonorailRequest(
path='/p/proj/issues/list?q=foo')
mr.me_user_id = 111L
self.mox.StubOutWithMock(frontendsearchpipeline,
'_StartBackendSearchCall')
a_fake_rpc = testing_helpers.Blank(callback=None)
rpc = frontendsearchpipeline._StartBackendSearchCall(
mr, ['proj'], 2, processed_invalidations_up_to,
failfast=False).AndReturn(a_fake_rpc)
self.mox.ReplayAll()
frontendsearchpipeline._HandleBackendSearchResponse(
mr, ['proj'], rpc_tuple, rpc_tuples, 2, filtered_iids,
search_limit_reached, processed_invalidations_up_to,
error_responses)
self.mox.VerifyAll()
_, retry_shard_id, retry_rpc = rpc_tuples[0]
self.assertEqual(2, retry_shard_id)
self.assertEqual(a_fake_rpc, retry_rpc)
self.assertIsNotNone(retry_rpc.callback)
self.assertEqual({}, filtered_iids)
self.assertEqual({}, search_limit_reached)
def testHandleBackendAtRiskResponse_TriggersRetry(self):
response_str = None
rpc = testing_helpers.Blank(
get_result=lambda: testing_helpers.Blank(content=response_str))
rpc_tuple = (NOW, 2, rpc)
rpc_tuples = [] # New RPC should be appended here
nonviewable_iids = {} # No change here until retry completes.
processed_invalidations_up_to = 12345
self.mox.StubOutWithMock(frontendsearchpipeline,
'_StartBackendNonviewableCall')
a_fake_rpc = testing_helpers.Blank(callback=None)
rpc = frontendsearchpipeline._StartBackendNonviewableCall(
789, 111L, 2, processed_invalidations_up_to,
failfast=False).AndReturn(a_fake_rpc)
self.mox.ReplayAll()
frontendsearchpipeline._HandleBackendNonviewableResponse(
789, 111L, 2, rpc_tuple, rpc_tuples, 2, nonviewable_iids,
processed_invalidations_up_to)
self.mox.VerifyAll()
_, retry_shard_id, retry_rpc = rpc_tuples[0]
self.assertEqual(2, retry_shard_id)
self.assertIsNotNone(retry_rpc.callback)
self.assertEqual(a_fake_rpc, retry_rpc)
self.assertEqual({}, nonviewable_iids)
def testHandleBackendSearchResponse_Normal(self):
response_str = ('})]\'\n'
'{'
' "unfiltered_iids": [10002, 10042],'
' "search_limit_reached": false'
'}')
rpc = testing_helpers.Blank(get_result=lambda: testing_helpers.Blank(
content=response_str, status_code=200))
rpc_tuple = (NOW, 2, rpc)
rpc_tuples = [] # Nothing should be added for this case.
filtered_iids = {} # Search results should accumlate here, per-shard.
search_limit_reached = {} # Booleans accumulate here, per-shard.
processed_invalidations_up_to = 12345
mr = testing_helpers.MakeMonorailRequest(
path='/p/proj/issues/list?q=foo')
mr.me_user_id = 111L
error_responses = set()
frontendsearchpipeline._HandleBackendSearchResponse(
mr, ['proj'], rpc_tuple, rpc_tuples, 2, filtered_iids,
search_limit_reached, processed_invalidations_up_to,
error_responses)
self.assertEqual([], rpc_tuples)
self.assertEqual({2: [10002, 10042]}, filtered_iids)
self.assertEqual({2: False}, search_limit_reached)
def testAddCCs(self):
self.rule.add_cc_ids.extend([111L, 222L])
view = filterrules_views.RuleView(
self.rule, {
111L: testing_helpers.Blank(email='*****@*****.**'),
222L: testing_helpers.Blank(email='*****@*****.**')
})
class IssueRefViewTest(unittest.TestCase):
issue1 = testing_helpers.Blank(issue_id=1,
local_id=1,
project_name='foo',
summary='blue screen')
issue2 = testing_helpers.Blank(issue_id=2,
local_id=2,
project_name='foo',
summary='hissing noise')
issue3 = testing_helpers.Blank(issue_id=3,
local_id=3,
project_name='foo',
summary='sinking feeling')
issue4 = testing_helpers.Blank(issue_id=4,
local_id=4,
project_name='bar',
summary='aliens among us')
def testNormalCase(self):
open_list = {1: self.issue1, 2: self.issue2}
closed_list = {3: self.issue3}
irv = tracker_views.IssueRefView('foo', self.issue1, open_list,
closed_list)
self.assertEquals(irv.visible, ezt.boolean(True))
self.assertEquals(irv.is_open, ezt.boolean(True))
self.assertEquals(irv.url, 'detail?id=1')
self.assertEquals(irv.display_name, 'issue 1')
self.assertEquals(irv.summary, 'blue screen')
irv = tracker_views.IssueRefView('foo', self.issue3, open_list,
closed_list)
self.assertEquals(irv.visible, ezt.boolean(True))
self.assertEquals(irv.is_open, ezt.boolean(False))
self.assertEquals(irv.url, 'detail?id=3')
self.assertEquals(irv.display_name, 'issue 3')
self.assertEquals(irv.summary, 'sinking feeling')
def testMissingIssueShouldNotBeVisible(self):
open_list = {1: self.issue1, 2: self.issue2}
closed_list = {3: self.issue3}
irv = tracker_views.IssueRefView('foo', None, open_list, closed_list)
self.assertEquals(irv.visible, ezt.boolean(False))
def testCrossProjectReference(self):
open_list = {1: self.issue1, 2: self.issue2}
closed_list = {3: self.issue3, 4: self.issue4}
irv = tracker_views.IssueRefView('foo', self.issue4, open_list,
closed_list)
self.assertEquals(irv.visible, ezt.boolean(True))
self.assertEquals(irv.is_open, ezt.boolean(False))
self.assertEquals(irv.url, '/p/bar%s?id=4' % urls.ISSUE_DETAIL)
self.assertEquals(irv.display_name, 'issue bar:4')
self.assertEquals(irv.summary, 'aliens among us')
def testAddCCs(self):
self.rule.add_cc_ids.extend([111, 222])
view = filterrules_views.RuleView(
self.rule, {
111: testing_helpers.Blank(email='*****@*****.**'),
222: testing_helpers.Blank(email='*****@*****.**')
})
self.assertEquals('label:a label:b', view.predicate)
self.assertEquals('add_ccs', view.action_type)
self.assertEquals('[email protected], [email protected]',
view.action_value)
def testGetParam_Normal(self):
request = testing_helpers.Blank(q='owner:me')
mar = monorailrequest.MonorailApiRequest(
request, self.services, cnxn=self.cnxn)
self.assertEqual(None, mar.GetParam('unknown'))
self.assertEqual(100, mar.GetParam('num'))
self.assertEqual('owner:me', mar.GetParam('q'))
request = testing_helpers.Blank(q='owner:me', maxResults=200)
mar = monorailrequest.MonorailApiRequest(
request, self.services, cnxn=self.cnxn)
self.assertEqual(200, mar.GetParam('num'))
def testIssueListURL_Customized_Nonmember(self):
mr = monorailrequest.MonorailRequest()
mr.query = None
mr.can = 2
mr.project = self.project
mr.config = self.config
mr.config.member_default_query = 'owner:me'
self.assertEqual('', mr._CalcDefaultQuery())
mr.auth = testing_helpers.Blank(effective_ids=set())
self.assertEqual('', mr._CalcDefaultQuery())
mr.auth = testing_helpers.Blank(effective_ids={999L})
self.assertEqual('', mr._CalcDefaultQuery())
def testHandleBackendNonviewableResponse_Normal(self):
response_str = ('})]\'\n' '{' ' "nonviewable": [10002, 10042]' '}')
rpc = testing_helpers.Blank(get_result=lambda: testing_helpers.Blank(
content=response_str, status_code=200))
rpc_tuple = (NOW, 2, rpc)
rpc_tuples = [] # Nothing should be added for this case.
nonviewable_iids = {
} # At-risk issue IDs should accumlate here, per-shard.
processed_invalidations_up_to = 12345
frontendsearchpipeline._HandleBackendNonviewableResponse(
789, 111L, 2, rpc_tuple, rpc_tuples, 2, nonviewable_iids,
processed_invalidations_up_to)
self.assertEqual([], rpc_tuples)
self.assertEqual({2: {10002, 10042}}, nonviewable_iids)
def testTableCellOwnerLastVisit(self):
test_issue = MakeTestIssue(4, 4, 'Four')
test_issue.owner_id = None
cell = tablecell.TableCellOwnerLastVisit(test_issue,
**self.table_cell_kws)
self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE)
self.assertEqual(cell.values, [])
test_issue.owner_id = 23456
self.USERS_BY_ID[23456].user = testing_helpers.Blank(
last_visit_timestamp=0)
cell = tablecell.TableCellOwnerLastVisit(test_issue,
**self.table_cell_kws)
self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE)
self.assertEqual(cell.values, [])
self.USERS_BY_ID[23456].user.last_visit_timestamp = int(time.time())
cell = tablecell.TableCellOwnerLastVisit(test_issue,
**self.table_cell_kws)
self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE)
self.assertEqual(cell.values[0].item, 'Today')
self.USERS_BY_ID[23456].user.last_visit_timestamp = (
int(time.time()) - 25 * framework_constants.SECS_PER_HOUR)
cell = tablecell.TableCellOwnerLastVisit(test_issue,
**self.table_cell_kws)
self.assertEqual(cell.type, table_view_helpers.CELL_TYPE_UNFILTERABLE)
self.assertEqual(cell.values[0].item, 'Yesterday')
def testAccumulateNonviewableIIDs_MemcacheStaleForProject(self):
self.mox.StubOutWithMock(frontendsearchpipeline,
'_StartBackendNonviewableCall')
processed_invalidations_up_to = 12345
cached_dict = {
'789;111;2': ([10002, 10042], processed_invalidations_up_to - 10),
'789;111;3': ([10003, 10093], processed_invalidations_up_to - 30),
}
rpc_tuples = [] # Nothing should accumulate here.
nonviewable_iids = {
1: {10001}
} # Nothing added here until RPC completes
project_shard_timestamps = {
(789, 1): 0, # not stale
(789, 2): processed_invalidations_up_to, # stale!
}
a_fake_rpc = testing_helpers.Blank(callback=None)
frontendsearchpipeline._StartBackendNonviewableCall(
789, 111L, 2, processed_invalidations_up_to).AndReturn(a_fake_rpc)
self.mox.ReplayAll()
frontendsearchpipeline._AccumulateNonviewableIIDs(
789, 111L, 2, cached_dict, nonviewable_iids,
project_shard_timestamps, rpc_tuples,
processed_invalidations_up_to)
self.mox.VerifyAll()
_, sid_0, rpc_0 = rpc_tuples[0]
self.assertEqual(2, sid_0)
self.assertEqual(a_fake_rpc, rpc_0)
self.assertIsNotNone(a_fake_rpc.callback)
self.assertEqual({1: {10001}}, nonviewable_iids)
def testInit_WithProjectAndIssue(self):
request = testing_helpers.Blank(
projectId='proj', issueId=1)
mar = monorailrequest.MonorailApiRequest(
request, self.services, cnxn=self.cnxn)
self.assertEqual(self.project, mar.project)
self.assertEqual(self.issue, mar.issue)
def testFetchSignedURL_Success(self, mock_fetch):
mock_fetch.return_value = testing_helpers.Blank(
headers={'Location': 'signed url'})
actual = gcs_helpers._FetchSignedURL('signing req url')
mock_fetch.assert_called_with('signing req url',
follow_redirects=False)
self.assertEquals('signed url', actual)
def testGetNonviewableIIDs_SearchHitNonviewableMissSoStartRPC(self):
"""If search hit and n-v miss, create RPCs to get nonviewable info."""
self.mox.StubOutWithMock(frontendsearchpipeline,
'_StartBackendNonviewableCall')
unfiltered_iids_dict = {
2: ['the search result issue_ids do not matter'],
}
rpc_tuples = [] # One RPC object should accumulate here.
nonviewable_iids = {} # This will stay empty until RPCs complete.
processed_invalidations_up_to = 12345
# Nothing is set in memcache for this case.
a_fake_rpc = testing_helpers.Blank(callback=None)
frontendsearchpipeline._StartBackendNonviewableCall(
789, 111L, 2, processed_invalidations_up_to).AndReturn(a_fake_rpc)
self.mox.ReplayAll()
frontendsearchpipeline._GetNonviewableIIDs(
[789], 111L, unfiltered_iids_dict.keys(), rpc_tuples,
nonviewable_iids, {}, processed_invalidations_up_to, True)
self.mox.VerifyAll()
_, sid_0, rpc_0 = rpc_tuples[0]
self.assertEqual(2, sid_0)
self.assertEqual({}, nonviewable_iids)
self.assertEqual(a_fake_rpc, rpc_0)
self.assertIsNotNone(a_fake_rpc.callback)
def testHandleRequest_ResultsExceedPagainationPage(self):
"""Return all result issue IDs, but only prefetch the first page."""
self.mr.num = 5
pipeline = testing_helpers.Blank(SearchForIIDs=lambda: None,
result_iids=[1, 2, 3, 4, 5, 6, 7, 8],
search_limit_reached=False,
error=None)
self.mox.StubOutWithMock(backendsearchpipeline,
'BackendSearchPipeline')
backendsearchpipeline.BackendSearchPipeline(self.mr, self.services,
self.servlet.profiler, 100,
['proj'], 111L,
222L).AndReturn(pipeline)
self.mox.StubOutWithMock(self.services.issue, 'GetIssues')
# First 5 issues are prefetched because num=5
self.services.issue.GetIssues(self.mr.cnxn, [1, 2, 3, 4, 5],
shard_id=2)
self.mox.ReplayAll()
json_data = self.servlet.HandleRequest(self.mr)
self.mox.VerifyAll()
# All are IDs are returned to the frontend.
self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8],
json_data['unfiltered_iids'])
self.assertFalse(json_data['search_limit_reached'])
self.assertEqual(None, json_data['error'])
def testDefaultOwner(self):
self.rule.default_owner_id = 111
view = filterrules_views.RuleView(
self.rule,
{111: testing_helpers.Blank(email='*****@*****.**')})
self.assertEquals('label:a label:b', view.predicate)
self.assertEquals('default_owner', view.action_type)
self.assertEquals('*****@*****.**', view.action_value)
def testHandleBackendNonviewableResponse_Error(self):
response_str = 'There was an error.'
rpc = testing_helpers.Blank(get_result=lambda: testing_helpers.Blank(
content=response_str, status_code=500))
rpc_tuple = (NOW, 2, rpc)
rpc_tuples = [] # Nothing should be added for this case.
nonviewable_iids = {
} # At-risk issue IDs should accumlate here, per-shard.
processed_invalidations_up_to = 12345
self.mox.StubOutWithMock(frontendsearchpipeline,
'_StartBackendNonviewableCall')
frontendsearchpipeline._HandleBackendNonviewableResponse(
789, 111L, 2, rpc_tuple, rpc_tuples, 0, nonviewable_iids,
processed_invalidations_up_to)
self.assertEqual([], rpc_tuples)
self.assertNotEqual({2: {10002, 10042}}, nonviewable_iids)
def testReceive_NoSuchUser(self):
"""When not found, log it and ignore without creating a user record."""
self.servlet.request = webapp2.Request.blank(
'/', POST={'raw-message': 'this is an email message'})
bounce_message = testing_helpers.Blank(
original={'to': '*****@*****.**'}, notification='notification')
self.servlet.receive(bounce_message)
self.assertEquals(1, len(self.services.user.users_by_id))
def testFieldEditPermitted_NoEdit(self):
page_perms = testing_helpers.Blank(
EditIssueSummary=False,
EditIssueStatus=False,
EditIssueOwner=False,
EditIssueCc=False) # no perms are needed.
self.assertTrue(
issuedetail._FieldEditPermitted([], '', '', '', '', 0, [],
page_perms))
def testReceive_Normal(self):
"""Find the user that bounced and set email_bounce_timestamp."""
self.assertEquals(0, self.user.email_bounce_timestamp)
bounce_message = testing_helpers.Blank(
original={'to': '*****@*****.**'})
self.servlet.receive(bounce_message)
self.assertNotEquals(0, self.user.email_bounce_timestamp)
def testFieldEditPermitted_AllNeededPerms(self):
page_perms = testing_helpers.Blank(EditIssueSummary=True,
EditIssueStatus=True,
EditIssueOwner=True,
EditIssueCc=True)
self.assertTrue(
issuedetail._FieldEditPermitted([], '', '', 'new sum',
'new status', 111L, [222L],
page_perms))
def testBlank(self):
blank = testing_helpers.Blank(
foo='foo',
bar=123,
inc=lambda x: x + 1)
self.assertEqual('foo', blank.foo)
self.assertEqual(123, blank.bar)
self.assertEqual(5, blank.inc(4))
def DoFiltering(self, perms, unsigned_user=False):
mr = testing_helpers.MakeMonorailRequest(
project=self.project, perms=perms)
if not unsigned_user:
mr.auth.user_id = 111L
mr.auth.user_view = testing_helpers.Blank(domain='jrobbins.org')
return issueoptions._FilterMemberData(
mr, [self.owner_email], [self.committer_email],
[self.contributor_email], [self.indirect_member_email])
def __init__(self, request=None):
response = testing_helpers.Blank()
super(TestableJsonFeed,
self).__init__(request or 'req',
response,
services=service_manager.Services())
self.response_data = None
self.handle_request_called = False
self.json_data = None
def testGetRequester_Oauth(self):
"""We get the email address of the signed in user using oauth."""
metadata = {}
# Signed out.
self.assertIsNone(self.svcr.GetRequester(metadata))
# Signed in with oauth.
self.mock_oauth_gcu.return_value = testing_helpers.Blank(
email=lambda: '*****@*****.**')
self.assertEqual('*****@*****.**',
self.svcr.GetRequester(metadata))
def testSearchForIIDs(self):
self.SetUpPromises('Priority:High')
self.mox.ReplayAll()
be_pipeline = backendsearchpipeline.BackendSearchPipeline(
self.mr, self.services, self.profiler, 100, ['proj'], 111L, 111L)
be_pipeline.result_iids_promise = testing_helpers.Blank(
WaitAndGetValue=lambda: ([10002, 10052], False, None))
be_pipeline.SearchForIIDs()
self.mox.VerifyAll()
self.assertEqual([10002, 10052], be_pipeline.result_iids)
self.assertEqual(False, be_pipeline.search_limit_reached)
def MakeRequestAsUser(self, project_name, email):
self.mox.StubOutWithMock(users, 'get_current_user')
users.get_current_user().AndReturn(
testing_helpers.Blank(email=lambda: email))
self.mox.ReplayAll()
request = webapp2.Request.blank('/p/' + project_name)
mr = monorailrequest.MonorailRequest()
prof = profiler.Profiler()
with prof.Phase('parse user info'):
mr.ParseRequest(request, self.services, prof)
return mr
def testHandleBackendSearchResponse_500(self):
response_str = 'There was a problem processing the query.'
rpc = testing_helpers.Blank(get_result=lambda: testing_helpers.Blank(
content=response_str, status_code=500))
rpc_tuple = (NOW, 2, rpc)
rpc_tuples = [] # Nothing should be added for this case.
filtered_iids = {} # Search results should accumlate here, per-shard.
search_limit_reached = {} # Booleans accumulate here, per-shard.
processed_invalidations_up_to = 12345
mr = testing_helpers.MakeMonorailRequest(
path='/p/proj/issues/list?q=foo')
mr.me_user_id = 111L
error_responses = set()
self.mox.StubOutWithMock(frontendsearchpipeline,
'_StartBackendSearchCall')
frontendsearchpipeline._HandleBackendSearchResponse(
mr, ['proj'], rpc_tuple, rpc_tuples, 0, filtered_iids,
search_limit_reached, processed_invalidations_up_to,
error_responses)
self.assertEqual([], rpc_tuples)
self.assertIn(2, error_responses)
def testFieldEditPermitted_NeededPermsNotOffered(self):
"""Even if user has all the field-level perms, they still can't do this."""
page_perms = testing_helpers.Blank(EditIssueSummary=True,
EditIssueStatus=True,
EditIssueOwner=True,
EditIssueCc=True)
self.assertFalse(
issuedetail._FieldEditPermitted(['NewLabel'], '', '', '', '', 0,
[], page_perms))
self.assertFalse(
issuedetail._FieldEditPermitted([], 'new blocked on', '', '', '',
0, [], page_perms))
self.assertFalse(
issuedetail._FieldEditPermitted([], '', 'new blocking', '', '', 0,
[], page_perms))
