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))