| # Copyright 2018 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Tests for converting between resource names and external ids.""" |
| from __future__ import print_function |
| from __future__ import division |
| from __future__ import absolute_import |
| |
| from mock import Mock, patch |
| import unittest |
| import re |
| |
| from api import resource_name_converters as rnc |
| from framework import exceptions |
| from testing import fake |
| from services import service_manager |
| from mrproto import tracker_pb2 |
| |
| class ResourceNameConverterTest(unittest.TestCase): |
| |
| def setUp(self): |
| self.services = service_manager.Services( |
| issue=fake.IssueService(), |
| project=fake.ProjectService(), |
| user=fake.UserService(), |
| features=fake.FeaturesService(), |
| template=fake.TemplateService(), |
| config=fake.ConfigService()) |
| self.cnxn = fake.MonorailConnection() |
| self.PAST_TIME = 12345 |
| self.project_1 = self.services.project.TestAddProject( |
| 'proj', project_id=789) |
| self.project_2 = self.services.project.TestAddProject( |
| 'goose', project_id=788) |
| self.dne_project_id = 1999 |
| |
| self.issue_1 = fake.MakeTestIssue( |
| self.project_1.project_id, 1, 'sum', 'New', 111, |
| project_name=self.project_1.project_name) |
| self.issue_2 = fake.MakeTestIssue( |
| self.project_2.project_id, 2, 'sum', 'New', 111, |
| project_name=self.project_2.project_name) |
| self.services.issue.TestAddIssue(self.issue_1) |
| self.services.issue.TestAddIssue(self.issue_2) |
| |
| 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) |
| |
| hotlist_items = [ |
| (self.issue_1.issue_id, 9, self.user_2.user_id, self.PAST_TIME, 'note'), |
| (self.issue_2.issue_id, 1, self.user_1.user_id, self.PAST_TIME, 'note')] |
| self.hotlist_1 = self.services.features.TestAddHotlist( |
| 'HotlistName', owner_ids=[], editor_ids=[], |
| hotlist_item_fields=hotlist_items) |
| |
| self.template_1 = self.services.template.TestAddIssueTemplateDef( |
| 1, self.project_1.project_id, 'template_1_name') |
| self.template_2 = self.services.template.TestAddIssueTemplateDef( |
| 2, self.project_2.project_id, 'template_2_name') |
| self.dne_template_id = 3 |
| |
| self.field_def_1_name = 'test_field' |
| self.field_def_1 = self.services.config.CreateFieldDef( |
| self.cnxn, self.project_1.project_id, self.field_def_1_name, 'STR_TYPE', |
| None, None, None, None, None, None, None, None, None, None, None, None, |
| None, None, [], []) |
| self.approval_def_1_name = 'approval_field_1' |
| self.approval_def_1_id = self.services.config.CreateFieldDef( |
| self.cnxn, self.project_1.project_id, self.approval_def_1_name, |
| 'APPROVAL_TYPE', None, None, None, None, None, None, None, None, None, |
| None, None, None, None, None, [], []) |
| self.component_def_1_path = 'Foo' |
| self.component_def_1_id = self.services.config.CreateComponentDef( |
| self.cnxn, self.project_1.project_id, self.component_def_1_path, '', |
| False, [], [], None, 111, []) |
| self.component_def_2_path = 'Foo>Bar>Hey123_I-am-valid' |
| self.component_def_2_id = self.services.config.CreateComponentDef( |
| self.cnxn, self.project_1.project_id, self.component_def_2_path, '', |
| False, [], [], None, 111, []) |
| self.component_def_3_path = 'Fizz' |
| self.component_def_3_id = self.services.config.CreateComponentDef( |
| self.cnxn, self.project_2.project_id, self.component_def_3_path, '', |
| False, [], [], None, 111, []) |
| self.dne_component_def_id = 999 |
| self.dne_field_def_id = 999999 |
| self.psq_1 = tracker_pb2.SavedQuery( |
| query_id=2, name='psq1 name', base_query_id=1, query='foo=bar') |
| self.psq_2 = tracker_pb2.SavedQuery( |
| query_id=3, name='psq2 name', base_query_id=1, query='fizz=buzz') |
| self.dne_psq_id = 987 |
| self.services.features.UpdateCannedQueries( |
| self.cnxn, self.project_1.project_id, [self.psq_1, self.psq_2]) |
| |
| def testGetResourceNameMatch(self): |
| """We can get a resource name match.""" |
| regex = re.compile(r'name\/(?P<group_name>[a-z]+)$') |
| match = rnc._GetResourceNameMatch('name/honque', regex) |
| self.assertEqual(match.group('group_name'), 'honque') |
| |
| def testGetResouceNameMatch_InvalidName(self): |
| """An exception is raised if there is not match.""" |
| regex = re.compile(r'name\/(?P<group_name>[a-z]+)$') |
| with self.assertRaises(exceptions.InputException): |
| rnc._GetResourceNameMatch('honque/honque', regex) |
| |
| def testIngestApprovalDefName(self): |
| approval_id = rnc.IngestApprovalDefName( |
| self.cnxn, 'projects/proj/approvalDefs/123', self.services) |
| self.assertEqual(approval_id, 123) |
| |
| def testIngestApprovalDefName_InvalidName(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestApprovalDefName( |
| self.cnxn, 'projects/proj/approvalDefs/123d', self.services) |
| |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestApprovalDefName( |
| self.cnxn, 'projects/garbage/approvalDefs/123', self.services) |
| |
| def testIngestFieldDefName(self): |
| """We can get a FieldDef's resource name match.""" |
| self.assertEqual( |
| rnc.IngestFieldDefName( |
| self.cnxn, 'projects/proj/fieldDefs/123', self.services), |
| (789, 123)) |
| |
| def testIngestFieldDefName_InvalidName(self): |
| """An exception is raised if the FieldDef's resource name is invalid""" |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestFieldDefName( |
| self.cnxn, 'projects/proj/fieldDefs/7Dog', self.services) |
| |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestFieldDefName( |
| self.cnxn, 'garbage/proj/fieldDefs/123', self.services) |
| |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestFieldDefName( |
| self.cnxn, 'projects/garbage/fieldDefs/123', self.services) |
| |
| def testIngestHotlistName(self): |
| """We can get a Hotlist's resource name match.""" |
| self.assertEqual(rnc.IngestHotlistName('hotlists/78909'), 78909) |
| |
| def testIngestHotlistName_InvalidName(self): |
| """An exception is raised if the Hotlist's resource name is invalid""" |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestHotlistName('hotlists/789honk789') |
| |
| def testIngestHotlistItemNames(self): |
| """We can get Issue IDs from HotlistItems resource names.""" |
| names = [ |
| 'hotlists/78909/items/proj.1', |
| 'hotlists/78909/items/goose.2'] |
| self.assertEqual( |
| rnc.IngestHotlistItemNames(self.cnxn, names, self.services), |
| [self.issue_1.issue_id, self.issue_2.issue_id]) |
| |
| def testIngestHotlistItemNames_ProjectNotFound(self): |
| """Exception is raised if a project is not found.""" |
| names = [ |
| 'hotlists/78909/items/proj.1', |
| 'hotlists/78909/items/chicken.2'] |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestHotlistItemNames(self.cnxn, names, self.services) |
| |
| def testIngestHotlistItemNames_MultipleProjectsNotFound(self): |
| """Aggregated exceptions raised if projects are not found.""" |
| names = [ |
| 'hotlists/78909/items/proj.1', 'hotlists/78909/items/chicken.2', |
| 'hotlists/78909/items/cow.3' |
| ] |
| with self.assertRaisesRegex(exceptions.NoSuchProjectException, |
| 'Project chicken not found.\n' + |
| 'Project cow not found.'): |
| rnc.IngestHotlistItemNames(self.cnxn, names, self.services) |
| |
| def testIngestHotlistItems_IssueNotFound(self): |
| """Exception is raised if an Issue is not found.""" |
| names = [ |
| 'hotlists/78909/items/proj.1', |
| 'hotlists/78909/items/goose.5'] |
| with self.assertRaisesRegex(exceptions.NoSuchIssueException, '%r' % names): |
| rnc.IngestHotlistItemNames(self.cnxn, names, self.services) |
| |
| def testConvertHotlistName(self): |
| """We can get a Hotlist's resource name.""" |
| self.assertEqual(rnc.ConvertHotlistName(10), 'hotlists/10') |
| |
| def testConvertHotlistItemNames(self): |
| """We can get Hotlist items' resource names.""" |
| expected_dict = { |
| self.hotlist_1.items[0].issue_id: |
| 'hotlists/%d/items/proj.1' % self.hotlist_1.hotlist_id, |
| self.hotlist_1.items[1].issue_id: |
| 'hotlists/%d/items/goose.2' % self.hotlist_1.hotlist_id, |
| } |
| self.assertEqual( |
| rnc.ConvertHotlistItemNames( |
| self.cnxn, self.hotlist_1.hotlist_id, expected_dict.keys(), |
| self.services), expected_dict) |
| |
| def testIngestApprovalValueName(self): |
| project_id, issue_id, approval_def_id = rnc.IngestApprovalValueName( |
| self.cnxn, 'projects/proj/issues/1/approvalValues/404', self.services) |
| self.assertEqual(project_id, self.project_1.project_id) |
| self.assertEqual(issue_id, self.issue_1.issue_id) |
| self.assertEqual(404, approval_def_id) # We don't verify it exists. |
| |
| def testIngestApprovalValueName_ProjectDoesNotExist(self): |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestApprovalValueName( |
| self.cnxn, 'projects/noproj/issues/1/approvalValues/1', self.services) |
| |
| def testIngestApprovalValueName_IssueDoesNotExist(self): |
| with self.assertRaisesRegex(exceptions.NoSuchIssueException, |
| 'projects/proj/issues/404'): |
| rnc.IngestApprovalValueName( |
| self.cnxn, 'projects/proj/issues/404/approvalValues/1', self.services) |
| |
| def testIngestApprovalValueName_InvalidStart(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestApprovalValueName( |
| self.cnxn, 'zprojects/proj/issues/1/approvalValues/1', self.services) |
| |
| def testIngestApprovalValueName_InvalidEnd(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestApprovalValueName( |
| self.cnxn, 'projects/proj/issues/1/approvalValues/1z', self.services) |
| |
| def testIngestApprovalValueName_InvalidCollection(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestApprovalValueName( |
| self.cnxn, 'projects/proj/issues/1/approvalValue/1', self.services) |
| |
| def testIngestIssueName(self): |
| """We can get an Issue global id from its resource name.""" |
| self.assertEqual( |
| rnc.IngestIssueName(self.cnxn, 'projects/proj/issues/1', self.services), |
| self.issue_1.issue_id) |
| |
| def testIngestIssueName_ProjectDoesNotExist(self): |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestIssueName(self.cnxn, 'projects/noproj/issues/1', self.services) |
| |
| def testIngestIssueName_IssueDoesNotExist(self): |
| with self.assertRaises(exceptions.NoSuchIssueException): |
| rnc.IngestIssueName(self.cnxn, 'projects/proj/issues/2', self.services) |
| |
| def testIngestIssueName_InvalidLocalId(self): |
| """Issue resource name Local IDs are digits.""" |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestIssueName(self.cnxn, 'projects/proj/issues/x', self.services) |
| |
| def testIngestIssueName_InvalidProjectId(self): |
| """Project names are more than 1 character.""" |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestIssueName(self.cnxn, 'projects/p/issues/1', self.services) |
| |
| def testIngestIssueName_InvalidFormat(self): |
| """Issue resource names must begin with the project resource name.""" |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestIssueName(self.cnxn, 'issues/1', self.services) |
| |
| def testIngestIssueName_Moved(self): |
| """We can get a moved issue.""" |
| moved_to_project_id = 987 |
| self.services.project.TestAddProject( |
| 'other', project_id=moved_to_project_id) |
| new_issue_id = 1010 |
| issue = fake.MakeTestIssue( |
| moved_to_project_id, 200, 'sum', 'New', 111, issue_id=new_issue_id) |
| self.services.issue.TestAddIssue(issue) |
| self.services.issue.TestAddMovedIssueRef( |
| self.project_1.project_id, 404, moved_to_project_id, 200) |
| |
| self.assertEqual( |
| rnc.IngestIssueName( |
| self.cnxn, 'projects/proj/issues/404', self.services), new_issue_id) |
| |
| def testIngestIssueNames(self): |
| """We can get an Issue global ids from resource names.""" |
| self.assertEqual( |
| rnc.IngestIssueNames( |
| self.cnxn, ['projects/proj/issues/1', 'projects/goose/issues/2'], |
| self.services), [self.issue_1.issue_id, self.issue_2.issue_id]) |
| |
| def testIngestIssueNames_EmptyList(self): |
| """We get an empty list when providing an empty list of issue names.""" |
| self.assertEqual(rnc.IngestIssueNames(self.cnxn, [], self.services), []) |
| |
| def testIngestIssueNames_WithBadInputs(self): |
| """We aggregate input exceptions.""" |
| with self.assertRaisesRegex( |
| exceptions.InputException, |
| 'Invalid resource name: projects/proj/badformat/1.\n' + |
| 'Invalid resource name: badformat/proj/issues/1.'): |
| rnc.IngestIssueNames( |
| self.cnxn, [ |
| 'projects/proj/badformat/1', 'badformat/proj/issues/1', |
| 'projects/proj/issues/1' |
| ], self.services) |
| |
| def testIngestIssueNames_OneDoesNotExist(self): |
| """We get an exception if one issue name provided does not exist.""" |
| with self.assertRaises(exceptions.NoSuchIssueException): |
| rnc.IngestIssueNames( |
| self.cnxn, ['projects/proj/issues/1', 'projects/proj/issues/2'], |
| self.services) |
| |
| def testIngestIssueNames_ManyDoNotExist(self): |
| """We get an exception if one issue name provided does not exist.""" |
| dne_issues = ['projects/proj/issues/2', 'projects/proj/issues/3'] |
| with self.assertRaisesRegex(exceptions.NoSuchIssueException, |
| '%r' % dne_issues): |
| rnc.IngestIssueNames(self.cnxn, dne_issues, self.services) |
| |
| def testIngestIssueNames_ProjectsNotExist(self): |
| """Aggregated exceptions raised if projects are not found.""" |
| with self.assertRaisesRegex(exceptions.NoSuchProjectException, |
| 'Project chicken not found.\n' + |
| 'Project cow not found.'): |
| rnc.IngestIssueNames( |
| self.cnxn, [ |
| 'projects/chicken/issues/2', 'projects/cow/issues/3', |
| 'projects/proj/issues/1' |
| ], self.services) |
| |
| def testIngestProjectFromIssue(self): |
| self.assertEqual(rnc.IngestProjectFromIssue('projects/xyz/issues/1'), 'xyz') |
| |
| def testIngestProjectFromIssue_InvalidName(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestProjectFromIssue('projects/xyz') |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestProjectFromIssue('garbage') |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestProjectFromIssue('projects/xyz/issues/garbage') |
| |
| def testIngestCommentName(self): |
| name = 'projects/proj/issues/1/comments/0' |
| actual = rnc.IngestCommentName(self.cnxn, name, self.services) |
| self.assertEqual( |
| actual, (self.project_1.project_id, self.issue_1.issue_id, 0)) |
| |
| def testIngestCommentName_InputException(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestCommentName(self.cnxn, 'misspelled name', self.services) |
| |
| def testIngestCommentName_NoSuchProject(self): |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestCommentName( |
| self.cnxn, 'projects/doesnotexist/issues/1/comments/0', self.services) |
| |
| def testIngestCommentName_NoSuchIssue(self): |
| with self.assertRaisesRegex(exceptions.NoSuchIssueException, |
| "['projects/proj/issues/404']"): |
| rnc.IngestCommentName( |
| self.cnxn, 'projects/proj/issues/404/comments/0', self.services) |
| |
| def testConvertCommentNames(self): |
| """We can create comment names.""" |
| expected = { |
| 0: 'projects/proj/issues/1/comments/0', |
| 1: 'projects/proj/issues/1/comments/1' |
| } |
| self.assertEqual(rnc.CreateCommentNames(1, 'proj', [0, 1]), expected) |
| |
| def testConvertCommentNames_Empty(self): |
| """Converting an empty list of comments returns an empty dict.""" |
| self.assertEqual(rnc.CreateCommentNames(1, 'proj', []), {}) |
| |
| def testConvertIssueName(self): |
| """We can create an Issue resource name from an issue_id.""" |
| self.assertEqual( |
| rnc.ConvertIssueName(self.cnxn, self.issue_1.issue_id, self.services), |
| 'projects/proj/issues/1') |
| |
| def testConvertIssueName_NotFound(self): |
| """Exception is raised if the issue is not found.""" |
| with self.assertRaises(exceptions.NoSuchIssueException): |
| rnc.ConvertIssueName(self.cnxn, 3279, self.services) |
| |
| def testConvertIssueNames(self): |
| """We can create Issue resource names from issue_ids.""" |
| self.assertEqual( |
| rnc.ConvertIssueNames( |
| self.cnxn, [self.issue_1.issue_id, 3279], self.services), |
| {self.issue_1.issue_id: 'projects/proj/issues/1'}) |
| |
| def testConvertApprovalValueNames(self): |
| """We can create ApprovalValue resource names.""" |
| self.issue_1.approval_values = [tracker_pb2.ApprovalValue( |
| approval_id=self.approval_def_1_id)] |
| |
| expected_name = ( |
| 'projects/proj/issues/1/approvalValues/%d' % self.approval_def_1_id) |
| self.assertEqual( |
| {self.approval_def_1_id: expected_name}, |
| rnc.ConvertApprovalValueNames( |
| self.cnxn, self.issue_1.issue_id, self.services)) |
| |
| def testIngestUserName(self): |
| """We can get a User ID from User resource name.""" |
| name = 'users/111' |
| self.assertEqual(rnc.IngestUserName(self.cnxn, name, self.services), 111) |
| |
| def testIngestUserName_DisplayName(self): |
| """We can get a User ID from User resource name with a display name set.""" |
| name = 'users/%s' % self.user_3.email |
| self.assertEqual(rnc.IngestUserName(self.cnxn, name, self.services), 333) |
| |
| def testIngestUserName_NoSuchUser(self): |
| """When autocreate=False, we raise an exception if a user is not found.""" |
| name = 'users/chicken@test.com' |
| with self.assertRaises(exceptions.NoSuchUserException): |
| rnc.IngestUserName(self.cnxn, name, self.services) |
| |
| def testIngestUserName_InvalidEmail(self): |
| """We raise an exception if a given resource name's email is invalid.""" |
| name = 'users/chickentest.com' |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestUserName(self.cnxn, name, self.services) |
| |
| def testIngestUserName_Autocreate(self): |
| """When autocreate=True create a new User if they don't already exist.""" |
| new_email = 'chicken@test.com' |
| name = 'users/%s' % new_email |
| user_id = rnc.IngestUserName( |
| self.cnxn, name, self.services, autocreate=True) |
| |
| new_id = self.services.user.LookupUserID( |
| self.cnxn, new_email, autocreate=False) |
| self.assertEqual(new_id, user_id) |
| |
| def testIngestUserNames(self): |
| """We can get User IDs from User resource names.""" |
| names = ['users/111', 'users/222', 'users/%s' % self.user_3.email] |
| expected_ids = [111, 222, 333] |
| self.assertEqual( |
| rnc.IngestUserNames(self.cnxn, names, self.services), expected_ids) |
| |
| def testIngestUserNames_NoSuchUser(self): |
| """When autocreate=False, we raise an exception if a user is not found.""" |
| names = [ |
| 'users/111', 'users/chicken@test.com', |
| 'users/%s' % self.user_3.email |
| ] |
| with self.assertRaises(exceptions.NoSuchUserException): |
| rnc.IngestUserNames(self.cnxn, names, self.services) |
| |
| def testIngestUserNames_InvalidEmail(self): |
| """We raise an exception if a given resource name's email is invalid.""" |
| names = [ |
| 'users/111', 'users/chickentest.com', |
| 'users/%s' % self.user_3.email |
| ] |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestUserNames(self.cnxn, names, self.services) |
| |
| def testIngestUserNames_Autocreate(self): |
| """When autocreate=True we create new Users if they don't already exist.""" |
| new_email = 'user_444@example.com' |
| names = [ |
| 'users/111', |
| 'users/%s' % new_email, |
| 'users/%s' % self.user_3.email |
| ] |
| ids = rnc.IngestUserNames(self.cnxn, names, self.services, autocreate=True) |
| |
| new_id = self.services.user.LookupUserID( |
| self.cnxn, new_email, autocreate=False) |
| expected_ids = [111, new_id, 333] |
| self.assertEqual(expected_ids, ids) |
| |
| def testConvertUserName(self): |
| """We can convert a single User ID to resource name.""" |
| self.assertEqual(rnc.ConvertUserName(111), 'users/111') |
| |
| def testConvertUserNames(self): |
| """We can get User resource names.""" |
| expected_dict = {111: 'users/111', 222: 'users/222', 333: 'users/333'} |
| self.assertEqual(rnc.ConvertUserNames(expected_dict.keys()), expected_dict) |
| |
| def testConvertUserNames_Empty(self): |
| """We can process an empty Users list.""" |
| self.assertEqual(rnc.ConvertUserNames([]), {}) |
| |
| def testConvertProjectStarName(self): |
| """We can convert a User ID and Project ID to resource name.""" |
| name = rnc.ConvertProjectStarName( |
| self.cnxn, 111, self.project_1.project_id, self.services) |
| expected = 'users/111/projectStars/{}'.format(self.project_1.project_name) |
| self.assertEqual(name, expected) |
| |
| def testConvertProjectStarName_NoSuchProjectException(self): |
| """Throws an exception when Project ID is invalid.""" |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertProjectStarName(self.cnxn, 111, 123455, self.services) |
| |
| def testIngestProjectName(self): |
| """We can get project name from Project resource names.""" |
| name = 'projects/{}'.format(self.project_1.project_name) |
| expected = self.project_1.project_id |
| self.assertEqual( |
| rnc.IngestProjectName(self.cnxn, name, self.services), expected) |
| |
| def testIngestProjectName_InvalidName(self): |
| """An exception is raised if the Hotlist's resource name is invalid""" |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestProjectName(self.cnxn, 'projects/', self.services) |
| |
| def testConvertTemplateNames(self): |
| """We can get IssueTemplate resource names.""" |
| expected_resource_name = 'projects/{}/templates/{}'.format( |
| self.project_1.project_name, self.template_1.template_id) |
| expected = {self.template_1.template_id: expected_resource_name} |
| |
| self.assertEqual( |
| rnc.ConvertTemplateNames( |
| self.cnxn, self.project_1.project_id, [self.template_1.template_id], |
| self.services), expected) |
| |
| def testConvertTemplateNames_NoSuchProjectException(self): |
| """We get an exception if project with id does not exist.""" |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertTemplateNames( |
| self.cnxn, self.dne_project_id, [self.template_1.template_id], |
| self.services) |
| |
| def testConvertTemplateNames_NonExistentTemplate(self): |
| """We only return templates that exist.""" |
| self.assertEqual( |
| rnc.ConvertTemplateNames( |
| self.cnxn, self.project_1.project_id, [self.dne_template_id], |
| self.services), {}) |
| |
| def testConvertTemplateNames_TemplateInProject(self): |
| """We only return templates in the project.""" |
| expected_resource_name = 'projects/{}/templates/{}'.format( |
| self.project_2.project_name, self.template_2.template_id) |
| expected = {self.template_2.template_id: expected_resource_name} |
| |
| self.assertEqual( |
| rnc.ConvertTemplateNames( |
| self.cnxn, self.project_2.project_id, |
| [self.template_1.template_id, self.template_2.template_id], |
| self.services), expected) |
| |
| def testIngestTemplateName(self): |
| name = 'projects/{}/templates/{}'.format( |
| self.project_1.project_name, self.template_1.template_id) |
| actual = rnc.IngestTemplateName(self.cnxn, name, self.services) |
| expected = (self.template_1.template_id, self.project_1.project_id) |
| self.assertEqual(actual, expected) |
| |
| def testIngestTemplateName_DoesNotExist(self): |
| """We will ingest templates that don't exist.""" |
| name = 'projects/{}/templates/{}'.format( |
| self.project_1.project_name, self.dne_template_id) |
| actual = rnc.IngestTemplateName(self.cnxn, name, self.services) |
| expected = (self.dne_template_id, self.project_1.project_id) |
| self.assertEqual(actual, expected) |
| |
| def testIngestTemplateName_InvalidName(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestTemplateName( |
| self.cnxn, 'projects/asdf/misspelled_template/123', self.services) |
| |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestTemplateName( |
| self.cnxn, 'projects/asdf/templates/123', self.services) |
| |
| def testConvertStatusDefNames(self): |
| """We can get Status resource name.""" |
| expected_resource_name = 'projects/{}/statusDefs/{}'.format( |
| self.project_1.project_name, self.issue_1.status) |
| |
| actual = rnc.ConvertStatusDefNames( |
| self.cnxn, [self.issue_1.status], self.project_1.project_id, |
| self.services) |
| self.assertEqual(actual[self.issue_1.status], expected_resource_name) |
| |
| def testConvertStatusDefNames_NoSuchProjectException(self): |
| """We can get an exception if project with id does not exist.""" |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertStatusDefNames( |
| self.cnxn, [self.issue_1.status], self.dne_project_id, self.services) |
| |
| def testConvertLabelDefNames(self): |
| """We can get Label resource names.""" |
| expected_label = 'some label' |
| expected_resource_name = 'projects/{}/labelDefs/{}'.format( |
| self.project_1.project_name, expected_label) |
| |
| self.assertEqual( |
| rnc.ConvertLabelDefNames( |
| self.cnxn, [expected_label], self.project_1.project_id, |
| self.services), {expected_label: expected_resource_name}) |
| |
| def testConvertLabelDefNames_NoSuchProjectException(self): |
| """We can get an exception if project with id does not exist.""" |
| some_label = 'some label' |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertLabelDefNames( |
| self.cnxn, [some_label], self.dne_project_id, self.services) |
| |
| def testConvertComponentDefNames(self): |
| """We can get Component resource names.""" |
| expected_id = 123456 |
| expected_resource_name = 'projects/{}/componentDefs/{}'.format( |
| self.project_1.project_name, expected_id) |
| |
| self.assertEqual( |
| rnc.ConvertComponentDefNames( |
| self.cnxn, [expected_id], self.project_1.project_id, self.services), |
| {expected_id: expected_resource_name}) |
| |
| def testConvertComponentDefNames_NoSuchProjectException(self): |
| """We can get an exception if project with id does not exist.""" |
| component_id = 123456 |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertComponentDefNames( |
| self.cnxn, [component_id], self.dne_project_id, self.services) |
| |
| def testIngestComponentDefNames(self): |
| names = [ |
| 'projects/proj/componentDefs/%d' % self.component_def_1_id, |
| 'projects/proj/componentDefs/%s' % self.component_def_2_path |
| ] |
| actual = rnc.IngestComponentDefNames(self.cnxn, names, self.services) |
| self.assertEqual(actual, [ |
| (self.project_1.project_id, self.component_def_1_id), |
| (self.project_1.project_id, self.component_def_2_id)]) |
| |
| def testIngestComponentDefNames_NoSuchProjectException(self): |
| names = ['projects/xyz/componentDefs/%d' % self.component_def_1_id] |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.IngestComponentDefNames(self.cnxn, names, self.services) |
| |
| names = ['projects/xyz/componentDefs/1', 'projects/zyz/componentDefs/1'] |
| expected_error = 'Project not found: xyz.\nProject not found: zyz.' |
| with self.assertRaisesRegex(exceptions.NoSuchProjectException, |
| expected_error): |
| rnc.IngestComponentDefNames(self.cnxn, names, self.services) |
| |
| def testIngestComponentDefNames_NoSuchComponentException(self): |
| names = ['projects/proj/componentDefs/%d' % self.dne_component_def_id] |
| with self.assertRaises(exceptions.NoSuchComponentException): |
| rnc.IngestComponentDefNames(self.cnxn, names, self.services) |
| |
| names = [ |
| 'projects/proj/componentDefs/999', 'projects/proj/componentDefs/cow' |
| ] |
| expected_error = 'Component not found: 999.\nComponent not found: \'cow\'.' |
| with self.assertRaisesRegex(exceptions.NoSuchComponentException, |
| expected_error): |
| rnc.IngestComponentDefNames(self.cnxn, names, self.services) |
| |
| def testIngestComponentDefNames_InvalidNames(self): |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestComponentDefNames( |
| self.cnxn, ['projects/proj/componentDefs/not.path.or.id'], |
| self.services) |
| |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestComponentDefNames( |
| self.cnxn, ['projects/proj/componentDefs/Foo>'], self.services) |
| |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestComponentDefNames( |
| self.cnxn, ['projects/proj/componentDefs/>Bar'], self.services) |
| |
| with self.assertRaises(exceptions.InputException): |
| rnc.IngestComponentDefNames( |
| self.cnxn, ['projects/proj/componentDefs/Foo>123Bar'], self.services) |
| |
| def testIngestComponentDefNames_CrossProject(self): |
| names = [ |
| 'projects/proj/componentDefs/%d' % self.component_def_1_id, |
| 'projects/goose/componentDefs/%s' % self.component_def_3_path |
| ] |
| actual = rnc.IngestComponentDefNames(self.cnxn, names, self.services) |
| self.assertEqual(actual, [ |
| (self.project_1.project_id, self.component_def_1_id), |
| (self.project_2.project_id, self.component_def_3_id)]) |
| |
| def testConvertFieldDefNames(self): |
| """Returns resource names for fields that exist and ignores others.""" |
| expected_key = self.field_def_1 |
| expected_value = 'projects/{}/fieldDefs/{}'.format( |
| self.project_1.project_name, self.field_def_1) |
| |
| field_ids = [self.field_def_1, self.dne_field_def_id] |
| self.assertEqual( |
| rnc.ConvertFieldDefNames( |
| self.cnxn, field_ids, self.project_1.project_id, self.services), |
| {expected_key: expected_value}) |
| |
| def testConvertFieldDefNames_NoSuchProjectException(self): |
| field_ids = [self.field_def_1, self.dne_field_def_id] |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertFieldDefNames( |
| self.cnxn, field_ids, self.dne_project_id, self.services) |
| |
| def testConvertApprovalDefNames(self): |
| outcome = rnc.ConvertApprovalDefNames( |
| self.cnxn, [self.approval_def_1_id], self.project_1.project_id, |
| self.services) |
| |
| expected_key = self.approval_def_1_id |
| expected_value = 'projects/{}/approvalDefs/{}'.format( |
| self.project_1.project_name, self.approval_def_1_id) |
| self.assertEqual(outcome, {expected_key: expected_value}) |
| |
| def testConvertApprovalDefNames_NoSuchProjectException(self): |
| approval_ids = [self.approval_def_1_id] |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertApprovalDefNames( |
| self.cnxn, approval_ids, self.dne_project_id, self.services) |
| |
| def testConvertProjectName(self): |
| self.assertEqual( |
| rnc.ConvertProjectName( |
| self.cnxn, self.project_1.project_id, self.services), |
| 'projects/{}'.format(self.project_1.project_name)) |
| |
| def testConvertProjectName_NoSuchProjectException(self): |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertProjectName(self.cnxn, self.dne_project_id, self.services) |
| |
| def testConvertProjectConfigName(self): |
| self.assertEqual( |
| rnc.ConvertProjectConfigName( |
| self.cnxn, self.project_1.project_id, self.services), |
| 'projects/{}/config'.format(self.project_1.project_name)) |
| |
| def testConvertProjectConfigName_NoSuchProjectException(self): |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertProjectConfigName( |
| self.cnxn, self.dne_project_id, self.services) |
| |
| def testConvertProjectMemberName(self): |
| self.assertEqual( |
| rnc.ConvertProjectMemberName( |
| self.cnxn, self.project_1.project_id, 111, self.services), |
| 'projects/{}/members/{}'.format(self.project_1.project_name, 111)) |
| |
| def testConvertProjectMemberName_NoSuchProjectException(self): |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertProjectMemberName( |
| self.cnxn, self.dne_project_id, 111, self.services) |
| |
| def testConvertProjectSavedQueryNames(self): |
| query_ids = [self.psq_1.query_id, self.psq_2.query_id, self.dne_psq_id] |
| outcome = rnc.ConvertProjectSavedQueryNames( |
| self.cnxn, query_ids, self.project_1.project_id, self.services) |
| |
| expected_value_1 = 'projects/{}/savedQueries/{}'.format( |
| self.project_1.project_name, self.psq_1.name) |
| expected_value_2 = 'projects/{}/savedQueries/{}'.format( |
| self.project_1.project_name, self.psq_2.name) |
| self.assertEqual( |
| outcome, { |
| self.psq_1.query_id: expected_value_1, |
| self.psq_2.query_id: expected_value_2 |
| }) |
| |
| def testConvertProjectSavedQueryNames_NoSuchProjectException(self): |
| with self.assertRaises(exceptions.NoSuchProjectException): |
| rnc.ConvertProjectSavedQueryNames( |
| self.cnxn, [self.psq_1.query_id], self.dne_project_id, self.services) |
