| # Copyright 2016 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unit tests for the field_helpers module.""" |
| from __future__ import print_function |
| from __future__ import division |
| from __future__ import absolute_import |
| |
| import time |
| import unittest |
| import re |
| |
| from framework import exceptions |
| from framework import permissions |
| from framework import template_helpers |
| from mrproto import project_pb2 |
| from mrproto import tracker_pb2 |
| from services import service_manager |
| from services import config_svc |
| from testing import fake |
| from testing import testing_helpers |
| from tracker import field_helpers |
| from tracker import tracker_bizobj |
| |
| |
| class FieldHelpersTest(unittest.TestCase): |
| |
| 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( |
| issue=fake.IssueService(), |
| usergroup=fake.UserGroupService(), |
| config=fake.ConfigService(), |
| user=fake.UserService()) |
| self.project = fake.Project() |
| self.mr = testing_helpers.MakeMonorailRequest( |
| project=self.project, services=self.services) |
| self.mr.cnxn = fake.MonorailConnection() |
| self.errors = template_helpers.EZTError() |
| |
| def testListApplicableFieldDefs(self): |
| issue_1 = fake.MakeTestIssue( |
| 789, |
| 1, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78901, |
| labels=['type-defect', 'other-label']) |
| issue_2 = fake.MakeTestIssue( |
| 789, |
| 2, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78902, |
| labels=['type-feedback', 'other-label1']) |
| issue_3 = fake.MakeTestIssue( |
| 789, |
| 3, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78903, |
| labels=['type-defect'], |
| approval_values=[ |
| tracker_pb2.ApprovalValue(approval_id=3), |
| tracker_pb2.ApprovalValue(approval_id=5) |
| ]) |
| issue_4 = fake.MakeTestIssue( |
| 789, 4, 'sum', 'New', 111, issue_id=78904) # test no labels at all |
| issue_5 = fake.MakeTestIssue( |
| 789, |
| 5, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78905, |
| labels=['type'], # test labels ignored |
| approval_values=[tracker_pb2.ApprovalValue(approval_id=5)]) |
| self.services.issue.TestAddIssue(issue_1) |
| self.services.issue.TestAddIssue(issue_2) |
| self.services.issue.TestAddIssue(issue_3) |
| self.services.issue.TestAddIssue(issue_4) |
| self.services.issue.TestAddIssue(issue_5) |
| fd_1 = tracker_pb2.FieldDef( |
| field_name='FirstField', |
| field_id=1, |
| field_type=tracker_pb2.FieldTypes.STR_TYPE, |
| applicable_type='feedback') # applicable |
| fd_2 = tracker_pb2.FieldDef( |
| field_name='SecField', |
| field_id=2, |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, |
| applicable_type='no') # not applicable |
| fd_3 = tracker_pb2.FieldDef( |
| field_name='LegalApproval', |
| field_id=3, |
| field_type=tracker_pb2.FieldTypes.APPROVAL_TYPE, |
| applicable_type='') # applicable |
| fd_4 = tracker_pb2.FieldDef( |
| field_name='UserField', |
| field_id=4, |
| field_type=tracker_pb2.FieldTypes.USER_TYPE, |
| applicable_type='') # applicable |
| fd_5 = tracker_pb2.FieldDef( |
| field_name='DogApproval', |
| field_id=5, |
| field_type=tracker_pb2.FieldTypes.APPROVAL_TYPE, |
| applicable_type='') # applicable |
| fd_6 = tracker_pb2.FieldDef( |
| field_name='SixthField', |
| field_id=6, |
| field_type=tracker_pb2.FieldTypes.INT_TYPE, |
| applicable_type='Defect') # applicable |
| fd_7 = tracker_pb2.FieldDef( |
| field_name='CatApproval', |
| field_id=7, |
| field_type=tracker_pb2.FieldTypes.APPROVAL_TYPE, |
| applicable_type='') # not applicable |
| config = tracker_bizobj.MakeDefaultProjectIssueConfig(789) |
| config.field_defs = [fd_1, fd_2, fd_3, fd_4, fd_5, fd_6, fd_7] |
| issues = [issue_1, issue_2, issue_3, issue_4, issue_5] |
| |
| actual_fds = field_helpers.ListApplicableFieldDefs(issues, config) |
| self.assertEqual(actual_fds, [fd_1, fd_3, fd_4, fd_5, fd_6]) |
| |
| def testParseFieldDefRequest_Empty(self): |
| post_data = fake.PostData() |
| parsed = field_helpers.ParseFieldDefRequest(post_data, self.config) |
| self.assertEqual('', parsed.field_name) |
| self.assertEqual(None, parsed.field_type_str) |
| self.assertEqual(None, parsed.min_value) |
| self.assertEqual(None, parsed.max_value) |
| self.assertEqual(None, parsed.regex) |
| self.assertFalse(parsed.needs_member) |
| self.assertEqual('', parsed.needs_perm) |
| self.assertEqual('', parsed.grants_perm) |
| self.assertEqual(0, parsed.notify_on) |
| self.assertFalse(parsed.is_required) |
| self.assertFalse(parsed.is_niche) |
| self.assertFalse(parsed.is_multivalued) |
| self.assertEqual('', parsed.field_docstring) |
| self.assertEqual('', parsed.choices_text) |
| self.assertEqual('', parsed.applicable_type) |
| self.assertEqual('', parsed.applicable_predicate) |
| unchanged_labels = [ |
| (label_def.label, label_def.label_docstring, label_def.deprecated) |
| for label_def in self.config.well_known_labels] |
| self.assertEqual(unchanged_labels, parsed.revised_labels) |
| self.assertEqual('', parsed.approvers_str) |
| self.assertEqual('', parsed.survey) |
| self.assertEqual('', parsed.parent_approval_name) |
| self.assertFalse(parsed.is_phase_field) |
| |
| def testParseFieldDefRequest_Normal(self): |
| post_data = fake.PostData( |
| name=['somefield'], |
| field_type=['INT_TYPE'], |
| min_value=['11'], |
| max_value=['99'], |
| regex=['.*'], |
| needs_member=['Yes'], |
| needs_perm=['Commit'], |
| grants_perm=['View'], |
| notify_on=['any_comment'], |
| importance=['required'], |
| is_multivalued=['Yes'], |
| docstring=['It is just some field'], |
| choices=['Hot = Lots of activity\nCold = Not much activity'], |
| applicable_type=['Defect'], |
| approver_names=['approver@chromium.org'], |
| survey=['Are there UX changes?'], |
| parent_approval_name=['UIReview'], |
| is_phase_field=['on'], |
| ) |
| parsed = field_helpers.ParseFieldDefRequest(post_data, self.config) |
| self.assertEqual('somefield', parsed.field_name) |
| self.assertEqual('INT_TYPE', parsed.field_type_str) |
| self.assertEqual(11, parsed.min_value) |
| self.assertEqual(99, parsed.max_value) |
| self.assertEqual('.*', parsed.regex) |
| self.assertTrue(parsed.needs_member) |
| self.assertEqual('Commit', parsed.needs_perm) |
| self.assertEqual('View', parsed.grants_perm) |
| self.assertEqual(1, parsed.notify_on) |
| self.assertTrue(parsed.is_required) |
| self.assertFalse(parsed.is_niche) |
| self.assertTrue(parsed.is_multivalued) |
| self.assertEqual('It is just some field', parsed.field_docstring) |
| self.assertEqual('Hot = Lots of activity\nCold = Not much activity', |
| parsed.choices_text) |
| self.assertEqual('Defect', parsed.applicable_type) |
| self.assertEqual('', parsed.applicable_predicate) |
| unchanged_labels = [ |
| (label_def.label, label_def.label_docstring, label_def.deprecated) |
| for label_def in self.config.well_known_labels] |
| new_labels = [ |
| ('somefield-Hot', 'Lots of activity', False), |
| ('somefield-Cold', 'Not much activity', False)] |
| self.assertEqual(unchanged_labels + new_labels, parsed.revised_labels) |
| self.assertEqual('approver@chromium.org', parsed.approvers_str) |
| self.assertEqual('Are there UX changes?', parsed.survey) |
| self.assertEqual('UIReview', parsed.parent_approval_name) |
| self.assertTrue(parsed.is_phase_field) |
| |
| def testParseFieldDefRequest_PreventPhaseApprovals(self): |
| post_data = fake.PostData( |
| field_type=['approval_type'], |
| is_phase_field=['on'], |
| ) |
| parsed = field_helpers.ParseFieldDefRequest(post_data, self.config) |
| self.assertEqual('approval_type', parsed.field_type_str) |
| self.assertFalse(parsed.is_phase_field) |
| |
| def testParseChoicesIntoWellKnownLabels_NewFieldDef(self): |
| choices_text = 'Hot = Lots of activity\nCold = Not much activity' |
| field_name = 'somefield' |
| revised_labels = field_helpers._ParseChoicesIntoWellKnownLabels( |
| choices_text, field_name, self.config, 'enum_type') |
| unchanged_labels = [ |
| (label_def.label, label_def.label_docstring, label_def.deprecated) |
| for label_def in self.config.well_known_labels] |
| new_labels = [ |
| ('somefield-Hot', 'Lots of activity', False), |
| ('somefield-Cold', 'Not much activity', False)] |
| self.assertEqual(unchanged_labels + new_labels, revised_labels) |
| |
| def testParseChoicesIntoWellKnownLabels_ConvertExistingLabel(self): |
| choices_text = 'High = Must be fixed\nMedium = Might slip' |
| field_name = 'Priority' |
| revised_labels = field_helpers._ParseChoicesIntoWellKnownLabels( |
| choices_text, field_name, self.config, 'enum_type') |
| kept_labels = [ |
| (label_def.label, label_def.label_docstring, label_def.deprecated) |
| for label_def in self.config.well_known_labels |
| if not label_def.label.startswith('Priority-')] |
| new_labels = [ |
| ('Priority-High', 'Must be fixed', False), |
| ('Priority-Medium', 'Might slip', False)] |
| self.maxDiff = None |
| self.assertEqual(kept_labels + new_labels, revised_labels) |
| |
| # TODO(jojwang): test this separately |
| # test None field_type_str, updating existing fielddef |
| self.config.field_defs.append(tracker_pb2.FieldDef( |
| field_id=13, field_name='Priority', |
| field_type=tracker_pb2.FieldTypes.ENUM_TYPE)) |
| revised_labels = field_helpers._ParseChoicesIntoWellKnownLabels( |
| choices_text, field_name, self.config, None) |
| self.assertEqual(kept_labels + new_labels, revised_labels) |
| |
| def testParseChoicesIntoWellKnownLabels_NotEnumField(self): |
| choices_text = '' |
| field_name = 'NotEnum' |
| self.config.well_known_labels = [ |
| tracker_pb2.LabelDef(label='NotEnum-Should'), |
| tracker_pb2.LabelDef(label='NotEnum-Not-Be-Masked')] |
| revised_labels = field_helpers._ParseChoicesIntoWellKnownLabels( |
| choices_text, field_name, self.config, 'str_type') |
| new_labels = [ |
| ('NotEnum-Should', None, False), |
| ('NotEnum-Not-Be-Masked', None, False)] |
| self.assertEqual(new_labels, revised_labels) |
| |
| # TODO(jojwang): test this separately |
| # test None field_type_str, updating existing fielddef |
| self.config.field_defs.append(tracker_pb2.FieldDef( |
| field_id=13, field_name='NotEnum', |
| field_type=tracker_pb2.FieldTypes.STR_TYPE)) |
| revised_labels = field_helpers._ParseChoicesIntoWellKnownLabels( |
| choices_text, field_name, self.config, None) |
| self.assertEqual(revised_labels, new_labels) |
| |
| def testShiftEnumFieldsIntoLabels_Empty(self): |
| labels = [] |
| labels_remove = [] |
| field_val_strs = {} |
| field_val_strs_remove = {} |
| field_helpers.ShiftEnumFieldsIntoLabels( |
| labels, labels_remove, field_val_strs, field_val_strs_remove, |
| self.config) |
| self.assertEqual([], labels) |
| self.assertEqual([], labels_remove) |
| self.assertEqual({}, field_val_strs) |
| self.assertEqual({}, field_val_strs_remove) |
| |
| def testShiftEnumFieldsIntoLabels_NoOp(self): |
| labels = ['Security', 'Performance', 'Pri-1', 'M-2'] |
| labels_remove = ['ReleaseBlock'] |
| field_val_strs = {123: ['CPU']} |
| field_val_strs_remove = {234: ['Small']} |
| field_helpers.ShiftEnumFieldsIntoLabels( |
| labels, labels_remove, field_val_strs, field_val_strs_remove, |
| self.config) |
| self.assertEqual(['Security', 'Performance', 'Pri-1', 'M-2'], labels) |
| self.assertEqual(['ReleaseBlock'], labels_remove) |
| self.assertEqual({123: ['CPU']}, field_val_strs) |
| self.assertEqual({234: ['Small']}, field_val_strs_remove) |
| |
| def testShiftEnumFieldsIntoLabels_FoundSomeEnumFields(self): |
| self.config.field_defs.append( |
| tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Component', tracker_pb2.FieldTypes.ENUM_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', 'What HW part is affected?', |
| False)) |
| self.config.field_defs.append( |
| tracker_bizobj.MakeFieldDef( |
| 234, 789, 'Size', tracker_pb2.FieldTypes.ENUM_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', 'How big is this work item?', |
| False)) |
| labels = ['Security', 'Performance', 'Pri-1', 'M-2'] |
| labels_remove = ['ReleaseBlock'] |
| field_val_strs = {123: ['CPU']} |
| field_val_strs_remove = {234: ['Small']} |
| field_helpers.ShiftEnumFieldsIntoLabels( |
| labels, labels_remove, field_val_strs, field_val_strs_remove, |
| self.config) |
| self.assertEqual( |
| ['Security', 'Performance', 'Pri-1', 'M-2', 'Component-CPU'], |
| labels) |
| self.assertEqual(['ReleaseBlock', 'Size-Small'], labels_remove) |
| self.assertEqual({}, field_val_strs) |
| self.assertEqual({}, field_val_strs_remove) |
| |
| def testReviseApprovals_New(self): |
| self.config.field_defs.append( |
| tracker_bizobj.MakeFieldDef( |
| 123, 789, 'UX Review', tracker_pb2.FieldTypes.APPROVAL_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', |
| 'Approval for UX review', False)) |
| existing_approvaldef = tracker_pb2.ApprovalDef( |
| approval_id=123, approver_ids=[101, 102], survey='') |
| self.config.approval_defs = [existing_approvaldef] |
| revised_approvals = field_helpers.ReviseApprovals( |
| 124, [103], '', self.config) |
| self.assertEqual(len(revised_approvals), 2) |
| self.assertEqual(revised_approvals, |
| [(123, [101, 102], ''), (124, [103], '')]) |
| |
| def testReviseApprovals_Existing(self): |
| existing_approvaldef = tracker_pb2.ApprovalDef( |
| approval_id=123, approver_ids=[101, 102], survey='') |
| self.config.approval_defs = [existing_approvaldef] |
| revised_approvals = field_helpers.ReviseApprovals( |
| 123, [103], '', self.config) |
| self.assertEqual(revised_approvals, [(123, [103], '')]) |
| |
| def testParseOneFieldValue_IntType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Foo', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = field_helpers.ParseOneFieldValue( |
| self.mr.cnxn, self.services.user, fd, '8675309') |
| self.assertEqual(fv.field_id, 123) |
| self.assertEqual(fv.int_value, 8675309) |
| |
| def testParseOneFieldValue_StrType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Foo', tracker_pb2.FieldTypes.STR_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = field_helpers.ParseOneFieldValue( |
| self.mr.cnxn, self.services.user, fd, '8675309') |
| self.assertEqual(fv.field_id, 123) |
| self.assertEqual(fv.str_value, '8675309') |
| |
| def testParseOneFieldValue_UserType(self): |
| self.services.user.TestAddUser('user@example.com', 111) |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Foo', tracker_pb2.FieldTypes.USER_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = field_helpers.ParseOneFieldValue( |
| self.mr.cnxn, self.services.user, fd, 'user@example.com') |
| self.assertEqual(fv.field_id, 123) |
| self.assertEqual(fv.user_id, 111) |
| |
| def testParseOneFieldValue_DateType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Deadline', tracker_pb2.FieldTypes.DATE_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = field_helpers.ParseOneFieldValue( |
| self.mr.cnxn, self.services.user, fd, '2009-02-13') |
| self.assertEqual(fv.field_id, 123) |
| self.assertEqual(fv.date_value, 1234483200) |
| |
| def testParseOneFieldValue_UrlType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Design Doc', tracker_pb2.FieldTypes.URL_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = field_helpers.ParseOneFieldValue( |
| self.mr.cnxn, self.services.user, fd, 'www.google.com') |
| self.assertEqual(fv.field_id, 123) |
| self.assertEqual(fv.url_value, 'http://www.google.com') |
| |
| def testParseOneFieldValue(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Target', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'milestone target', |
| False, is_phase_field=True) |
| phase_fvs = field_helpers.ParseOnePhaseFieldValue( |
| self.mr.cnxn, self.services.user, fd, '70', [30, 40]) |
| self.assertEqual(len(phase_fvs), 2) |
| self.assertEqual(phase_fvs[0].phase_id, 30) |
| self.assertEqual(phase_fvs[1].phase_id, 40) |
| |
| def testParseFieldValues_Empty(self): |
| field_val_strs = {} |
| phase_field_val_strs = {} |
| field_values = field_helpers.ParseFieldValues( |
| self.mr.cnxn, self.services.user, field_val_strs, |
| phase_field_val_strs, self.config) |
| self.assertEqual([], field_values) |
| |
| def testParseFieldValues_EmptyPhases(self): |
| field_val_strs = {126: ['70']} |
| phase_field_val_strs = {} |
| fd_phase = tracker_bizobj.MakeFieldDef( |
| 126, 789, 'Target', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'milestone target', |
| False, is_phase_field=True) |
| self.config.field_defs.extend([fd_phase]) |
| field_values = field_helpers.ParseFieldValues( |
| self.mr.cnxn, self.services.user, field_val_strs, |
| phase_field_val_strs, self.config) |
| self.assertEqual([], field_values) |
| |
| def testParseFieldValues_Normal(self): |
| fd_int = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fd_date = tracker_bizobj.MakeFieldDef( |
| 124, 789, 'Deadline', tracker_pb2.FieldTypes.DATE_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fd_url = tracker_bizobj.MakeFieldDef( |
| 125, 789, 'Design Doc', tracker_pb2.FieldTypes.URL_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fd_phase = tracker_bizobj.MakeFieldDef( |
| 126, 789, 'Target', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'milestone target', |
| False, is_phase_field=True) |
| self.config.field_defs.extend([fd_int, fd_date, fd_url, fd_phase]) |
| field_val_strs = { |
| 123: ['80386', '68040'], |
| 124: ['2009-02-13'], |
| 125: ['www.google.com'], |
| } |
| phase_field_val_strs = { |
| 126: {'beta': ['89'], |
| 'stable': ['70'], |
| 'missing': ['234'], |
| }} |
| field_values = field_helpers.ParseFieldValues( |
| self.mr.cnxn, self.services.user, field_val_strs, |
| phase_field_val_strs, self.config, |
| phase_ids_by_name={'stable': [30, 40], 'beta': [88]}) |
| fv1 = tracker_bizobj.MakeFieldValue( |
| 123, 80386, None, None, None, None, False) |
| fv2 = tracker_bizobj.MakeFieldValue( |
| 123, 68040, None, None, None, None, False) |
| fv3 = tracker_bizobj.MakeFieldValue( |
| 124, None, None, None, 1234483200, None, False) |
| fv4 = tracker_bizobj.MakeFieldValue( |
| 125, None, None, None, None, 'http://www.google.com', False) |
| fv5 = tracker_bizobj.MakeFieldValue( |
| 126, 89, None, None, None, None, False, phase_id=88) |
| fv6 = tracker_bizobj.MakeFieldValue( |
| 126, 70, None, None, None, None, False, phase_id=30) |
| fv7 = tracker_bizobj.MakeFieldValue( |
| 126, 70, None, None, None, None, False, phase_id=40) |
| self.assertEqual([fv1, fv2, fv3, fv4, fv5, fv6, fv7], field_values) |
| |
| def test_IntType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = tracker_bizobj.MakeFieldValue(123, 8086, None, None, None, None, False) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| fd.min_value = 1 |
| fd.max_value = 999 |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertEqual('Value must be <= 999.', msg) |
| |
| fv.int_value = 0 |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertEqual('Value must be >= 1.', msg) |
| |
| def test_StrType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.STR_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = tracker_bizobj.MakeFieldValue( |
| 123, None, 'i386', None, None, None, False) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| fd.regex = r'^\d*$' |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertEqual(r'Value must match regular expression: ^\d*$.', msg) |
| |
| fv.str_value = '386' |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| def test_UserType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Fake Field', tracker_pb2.FieldTypes.USER_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| |
| self.services.user.TestAddUser('owner@example.com', 111) |
| self.mr.project.owner_ids.extend([111]) |
| owner = tracker_bizobj.MakeFieldValue( |
| fd.field_id, None, None, 111, None, None, False) |
| |
| self.services.user.TestAddUser('committer@example.com', 222) |
| self.mr.project.committer_ids.extend([222]) |
| self.mr.project.extra_perms = [ |
| project_pb2.Project.ExtraPerms( |
| member_id=222, |
| perms=['FooPerm'])] |
| committer = tracker_bizobj.MakeFieldValue( |
| fd.field_id, None, None, 222, None, None, False) |
| |
| self.services.user.TestAddUser('user@example.com', 333) |
| user = tracker_bizobj.MakeFieldValue( |
| fd.field_id, None, None, 333, None, None, False) |
| |
| # Normal |
| for fv in (owner, committer, user): |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| # Needs to be member (user isn't a member). |
| fd.needs_member = True |
| for fv in (owner, committer): |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, user) |
| self.assertEqual('User must be a member of the project.', msg) |
| |
| # Needs DeleteAny permission (only owner has it). |
| fd.needs_perm = 'DeleteAny' |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, owner) |
| self.assertIsNone(msg) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, committer) |
| self.assertEqual('User must have permission "DeleteAny".', msg) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, user) |
| self.assertEqual('User must be a member of the project.', msg) |
| |
| # Needs custom permission (only committer has it). |
| fd.needs_perm = 'FooPerm' |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, owner) |
| self.assertEqual('User must have permission "FooPerm".', msg) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, committer) |
| self.assertIsNone(msg) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, user) |
| self.assertEqual('User must be a member of the project.', msg) |
| |
| def test_DateType(self): |
| pass # TODO(jrobbins): write this test. @@@ |
| |
| def test_UrlType(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.URL_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| |
| fv = tracker_bizobj.MakeFieldValue( |
| 123, None, None, None, None, 'www.google.com', False) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| fv.url_value = 'go/puppies' |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| fv.url_value = 'go/213' |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| fv.url_value = 'puppies' |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertEqual('Value must be a valid url.', msg) |
| |
| def test_OtherType(self): |
| # There are currently no validation options for date-type custom fields. |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'Deadline', tracker_pb2.FieldTypes.DATE_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| fv = tracker_bizobj.MakeFieldValue( |
| 123, None, None, None, 1234567890, None, False) |
| msg = field_helpers.ValidateCustomFieldValue( |
| self.mr.cnxn, self.mr.project, self.services, fd, fv) |
| self.assertIsNone(msg) |
| |
| def testValidateCustomFields_NoCustomFieldValues(self): |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, self.services, [], self.config, self.mr.project, |
| ezt_errors=self.errors) |
| self.assertFalse(self.errors.AnyErrors()) |
| self.assertEqual(err_msgs, []) |
| |
| def testValidateCustomFields_NoErrors(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.config.field_defs.append(fd) |
| fv1 = tracker_bizobj.MakeFieldValue( |
| 123, 8086, None, None, None, None, False) |
| fv2 = tracker_bizobj.MakeFieldValue(123, 486, None, None, None, None, False) |
| |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, self.services, [fv1, fv2], self.config, self.mr.project, |
| ezt_errors=self.errors) |
| self.assertFalse(self.errors.AnyErrors()) |
| self.assertEqual(err_msgs, []) |
| |
| def testValidateCustomFields_SomeValueErrors(self): |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.config.field_defs.append(fd) |
| fv1 = tracker_bizobj.MakeFieldValue( |
| 123, 8086, None, None, None, None, False) |
| fv2 = tracker_bizobj.MakeFieldValue(123, 486, None, None, None, None, False) |
| |
| fd.min_value = 1 |
| fd.max_value = 999 |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, self.services, [fv1, fv2], self.config, self.mr.project, |
| ezt_errors=self.errors) |
| self.assertTrue(self.errors.AnyErrors()) |
| self.assertEqual(1, len(self.errors.custom_fields)) |
| custom_field_error = self.errors.custom_fields[0] |
| self.assertEqual(123, custom_field_error.field_id) |
| self.assertEqual('Value must be <= 999.', custom_field_error.message) |
| self.assertEqual(len(err_msgs), 1) |
| self.assertTrue(re.search(r'Value must be <= 999.', err_msgs[0])) |
| |
| def testValidateCustomFields_DeletedRequiredFields_Ignored(self): |
| issue = fake.MakeTestIssue( |
| 789, |
| 1, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78901, |
| labels=['type-defect', 'other-label']) |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, '', False, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', True) |
| self.config.field_defs.append(fd) |
| |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, |
| self.services, [], |
| self.config, |
| self.mr.project, |
| ezt_errors=self.errors, |
| issue=issue) |
| self.assertFalse(self.errors.AnyErrors()) |
| self.assertEqual(err_msgs, []) |
| |
| def testValidateCustomFields_RequiredFields_Normal(self): |
| issue = fake.MakeTestIssue( |
| 789, |
| 1, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78901, |
| labels=['type-defect', 'other-label']) |
| |
| required = True |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, '', required, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.config.field_defs.append(fd) |
| fv1 = tracker_bizobj.MakeFieldValue( |
| 123, 8086, None, None, None, None, False) |
| fv2 = tracker_bizobj.MakeFieldValue(123, 486, None, None, None, None, False) |
| |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, |
| self.services, [fv1, fv2], |
| self.config, |
| self.mr.project, |
| issue=issue) |
| self.assertEqual(len(err_msgs), 0) |
| |
| def testValidateCustomFields_RequiredFields_ErrorsWhenMissing(self): |
| issue = fake.MakeTestIssue( |
| 789, |
| 1, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78901, |
| labels=['type-defect', 'other-label']) |
| |
| required = True |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.INT_TYPE, None, '', required, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.config.field_defs.append(fd) |
| |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, self.services, [], self.config, self.mr.project, issue=issue) |
| self.assertEqual(len(err_msgs), 1) |
| self.assertTrue(re.search(r'CPU field is required.', err_msgs[0])) |
| |
| def testValidateCustomFields_RequiredFields_EnumFieldNormal(self): |
| # Enums are a special case because their values are stored in labels. |
| issue = fake.MakeTestIssue( |
| 789, |
| 1, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78901, |
| labels=['type-defect', 'other-label', 'CPU-enum-value']) |
| required = True |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.ENUM_TYPE, None, '', required, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.config.field_defs.append(fd) |
| |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, self.services, [], self.config, self.mr.project, issue=issue) |
| self.assertEqual(len(err_msgs), 0) |
| |
| def testValidateCustomFields_RequiredFields_EnumFieldMultiWord(self): |
| # Enum fields with dashes in them require special label prefix parsing. |
| issue = fake.MakeTestIssue( |
| 789, |
| 1, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78901, |
| labels=['type-defect', 'other-label', 'an-enum-value']) |
| required = True |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'an-enum', tracker_pb2.FieldTypes.ENUM_TYPE, None, '', |
| required, False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.config.field_defs.append(fd) |
| |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, self.services, [], self.config, self.mr.project, issue=issue) |
| self.assertEqual(len(err_msgs), 0) |
| |
| def testValidateCustomFields_RequiredFields_EnumFieldError(self): |
| # Enums are a special case because their values are stored in labels. |
| issue = fake.MakeTestIssue( |
| 789, |
| 1, |
| 'sum', |
| 'New', |
| 111, |
| issue_id=78901, |
| labels=['type-defect', 'other-label']) |
| required = True |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'CPU', tracker_pb2.FieldTypes.ENUM_TYPE, None, '', required, |
| False, False, None, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False) |
| self.config.field_defs.append(fd) |
| |
| err_msgs = field_helpers.ValidateCustomFields( |
| self.mr, self.services, [], self.config, self.mr.project, issue=issue) |
| self.assertEqual(len(err_msgs), 1) |
| self.assertTrue(re.search(r'CPU field is required.', err_msgs[0])) |
| |
| def testAssertCustomFieldsEditPerms_Empty(self): |
| self.assertIsNone( |
| field_helpers.AssertCustomFieldsEditPerms( |
| self.mr, self.config, [], [], [], [], [])) |
| |
| def testAssertCustomFieldsEditPerms_Normal(self): |
| self.services.user.TestAddUser('user@example.com', 222) |
| self.mr.auth.effective_ids = {222} |
| fd_int = tracker_bizobj.MakeFieldDef( |
| 11111, |
| 1, |
| 'fdInt', |
| tracker_pb2.FieldTypes.INT_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| fd_str = tracker_bizobj.MakeFieldDef( |
| 22222, |
| 1, |
| 'fdStr', |
| tracker_pb2.FieldTypes.STR_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| fd_date = tracker_bizobj.MakeFieldDef( |
| 33333, |
| 1, |
| 'fdDate', |
| tracker_pb2.FieldTypes.DATE_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| fd_enum1 = tracker_bizobj.MakeFieldDef( |
| 44444, |
| 1, |
| 'fdEnum1', |
| tracker_pb2.FieldTypes.ENUM_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| fd_enum2 = tracker_bizobj.MakeFieldDef( |
| 55555, |
| 1, |
| 'fdEnum2', |
| tracker_pb2.FieldTypes.ENUM_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| self.config.field_defs = [fd_int, fd_str, fd_date, fd_enum1, fd_enum2] |
| fv1 = tracker_bizobj.MakeFieldValue( |
| 11111, 37, None, None, None, None, False) |
| fv2 = tracker_bizobj.MakeFieldValue( |
| 22222, None, 'Chicken', None, None, None, False) |
| self.assertIsNone( |
| field_helpers.AssertCustomFieldsEditPerms( |
| self.mr, self.config, [fv1], [fv2], [33333], ['Dog', 'fdEnum1-a'], |
| ['Cat', 'fdEnum2-b'])) |
| |
| def testAssertCustomFieldsEditPerms_Reject(self): |
| self.mr.perms = permissions.PermissionSet([]) |
| fd_int = tracker_bizobj.MakeFieldDef( |
| 11111, |
| 1, |
| 'fdInt', |
| tracker_pb2.FieldTypes.INT_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| fd_enum = tracker_bizobj.MakeFieldDef( |
| 44444, |
| 1, |
| 'fdEnum', |
| tracker_pb2.FieldTypes.ENUM_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| self.config.field_defs = [fd_int, fd_enum] |
| fv = tracker_bizobj.MakeFieldValue(11111, 37, None, None, None, None, False) |
| |
| self.assertRaises( |
| AssertionError, field_helpers.AssertCustomFieldsEditPerms, self.mr, |
| self.config, [fv], [], [], [], []) |
| |
| self.assertRaises( |
| AssertionError, field_helpers.AssertCustomFieldsEditPerms, self.mr, |
| self.config, [], [fv], [], [], []) |
| |
| self.assertRaises( |
| AssertionError, field_helpers.AssertCustomFieldsEditPerms, self.mr, |
| self.config, [], [], [11111], [], []) |
| |
| self.assertRaises( |
| AssertionError, field_helpers.AssertCustomFieldsEditPerms, self.mr, |
| self.config, [], [], [], ['Dog', 'fdEnum-a'], []) |
| |
| self.assertRaises( |
| AssertionError, field_helpers.AssertCustomFieldsEditPerms, self.mr, |
| self.config, [], [], [], [], ['Cat', 'fdEnum-b']) |
| |
| def testApplyRestrictedDefaultValues(self): |
| self.mr.perms = permissions.PermissionSet([]) |
| self.services.user.TestAddUser('user@example.com', 222) |
| self.mr.auth.effective_ids = {222} |
| fd_int = tracker_bizobj.MakeFieldDef( |
| 11111, |
| 1, |
| 'fdInt', |
| tracker_pb2.FieldTypes.INT_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=False) |
| fd_str = tracker_bizobj.MakeFieldDef( |
| 22222, |
| 1, |
| 'fdStr', |
| tracker_pb2.FieldTypes.STR_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| fd_str_2 = tracker_bizobj.MakeFieldDef( |
| 33333, |
| 1, |
| 'fdStr_2', |
| tracker_pb2.FieldTypes.STR_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=False) |
| fd_enum = tracker_bizobj.MakeFieldDef( |
| 44444, |
| 1, |
| 'fdEnum', |
| tracker_pb2.FieldTypes.ENUM_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=False) |
| fd_restricted_enum = tracker_bizobj.MakeFieldDef( |
| 55555, |
| 1, |
| 'fdRestrictedEnum', |
| tracker_pb2.FieldTypes.ENUM_TYPE, |
| None, |
| '', |
| False, |
| False, |
| False, |
| None, |
| None, |
| '', |
| False, |
| '', |
| '', |
| tracker_pb2.NotifyTriggers.NEVER, |
| 'no_action', |
| 'doc', |
| False, |
| is_restricted_field=True) |
| self.config.field_defs = [ |
| fd_int, fd_str, fd_str_2, fd_enum, fd_restricted_enum |
| ] |
| fv = tracker_bizobj.MakeFieldValue( |
| 33333, None, 'Happy', None, None, None, False) |
| temp_fv = tracker_bizobj.MakeFieldValue( |
| 11111, 37, None, None, None, None, False) |
| temp_restricted_fv = tracker_bizobj.MakeFieldValue( |
| 22222, None, 'Chicken', None, None, None, False) |
| field_vals = [fv] |
| labels = ['Car', 'Bus'] |
| temp_field_vals = [temp_fv, temp_restricted_fv] |
| temp_labels = ['Bike', 'fdEnum-a', 'fdRestrictedEnum-b'] |
| field_helpers.ApplyRestrictedDefaultValues( |
| self.mr, self.config, field_vals, labels, temp_field_vals, temp_labels) |
| self.assertEqual(labels, ['Car', 'Bus', 'fdRestrictedEnum-b']) |
| self.assertEqual(field_vals, [fv, temp_restricted_fv]) |
| |
| def testFormatUrlFieldValue(self): |
| self.assertEqual('http://www.google.com', |
| field_helpers.FormatUrlFieldValue('www.google.com')) |
| self.assertEqual('https://www.bing.com', |
| field_helpers.FormatUrlFieldValue('https://www.bing.com')) |
| |
| def testReviseFieldDefFromParsed_INT(self): |
| parsed_field_def = field_helpers.ParsedFieldDef( |
| 'EstDays', |
| 'int_type', |
| min_value=5, |
| max_value=7, |
| regex='', |
| needs_member=True, |
| needs_perm='Commit', |
| grants_perm='View', |
| notify_on=tracker_pb2.NotifyTriggers.ANY_COMMENT, |
| is_required=True, |
| is_niche=True, |
| importance='required', |
| is_multivalued=True, |
| field_docstring='updated doc', |
| choices_text='', |
| applicable_type='Launch', |
| applicable_predicate='', |
| revised_labels=[], |
| date_action_str='ping_participants', |
| approvers_str='', |
| survey='', |
| parent_approval_name='', |
| is_phase_field=False, |
| is_restricted_field=False) |
| |
| fd = tracker_bizobj.MakeFieldDef( |
| 123, 789, 'EstDays', tracker_pb2.FieldTypes.INT_TYPE, None, |
| '', False, False, False, 4, None, '', False, '', '', |
| tracker_pb2.NotifyTriggers.NEVER, 'no_action', 'doc', False, |
| approval_id=3) |
| |
| new_fd = field_helpers.ReviseFieldDefFromParsed(parsed_field_def, fd) |
| # assert INT fields |
| self.assertEqual(new_fd.min_value, 5) |
| self.assertEqual(new_fd.max_value, 7) |
| |
| # assert USER fields |
| self.assertEqual(new_fd.notify_on, tracker_pb2.NotifyTriggers.ANY_COMMENT) |
| self.assertTrue(new_fd.needs_member) |
| self.assertEqual(new_fd.needs_perm, 'Commit') |
| self.assertEqual(new_fd.grants_perm, 'View') |
| |
| # assert DATE fields |
| self.assertEqual(new_fd.date_action, |
| tracker_pb2.DateAction.PING_PARTICIPANTS) |
| |
| # assert general fields |
| self.assertTrue(new_fd.is_required) |
| self.assertTrue(new_fd.is_niche) |
| self.assertEqual(new_fd.applicable_type, 'Launch') |
| self.assertEqual(new_fd.docstring, 'updated doc') |
| self.assertTrue(new_fd.is_multivalued) |
| self.assertEqual(new_fd.approval_id, 3) |
| self.assertFalse(new_fd.is_phase_field) |
| self.assertFalse(new_fd.is_restricted_field) |
| |
| def testParsedFieldDefAssertions_Accepted(self): |
| parsed_fd = field_helpers.ParsedFieldDef( |
| 'EstDays', |
| 'int_type', |
| min_value=5, |
| max_value=7, |
| regex='', |
| needs_member=True, |
| needs_perm='Commit', |
| grants_perm='View', |
| notify_on=tracker_pb2.NotifyTriggers.ANY_COMMENT, |
| is_required=True, |
| is_niche=False, |
| importance='required', |
| is_multivalued=True, |
| field_docstring='updated doc', |
| choices_text='', |
| applicable_type='Launch', |
| applicable_predicate='', |
| revised_labels=[], |
| date_action_str='ping_participants', |
| approvers_str='', |
| survey='', |
| parent_approval_name='', |
| is_phase_field=False, |
| is_restricted_field=False) |
| |
| field_helpers.ParsedFieldDefAssertions(self.mr, parsed_fd) |
| self.assertFalse(self.mr.errors.AnyErrors()) |
| |
| def testParsedFieldDefAssertions_Rejected(self): |
| parsed_fd = field_helpers.ParsedFieldDef( |
| 'restrictApprovalField', |
| 'approval_type', |
| min_value=10, |
| max_value=7, |
| regex='/foo(?)/', |
| needs_member=True, |
| needs_perm='Commit', |
| grants_perm='View', |
| notify_on=tracker_pb2.NotifyTriggers.ANY_COMMENT, |
| is_required=True, |
| is_niche=True, |
| importance='required', |
| is_multivalued=True, |
| field_docstring='updated doc', |
| choices_text='', |
| applicable_type='Launch', |
| applicable_predicate='', |
| revised_labels=[], |
| date_action_str='custom_date_action_str', |
| approvers_str='', |
| survey='', |
| parent_approval_name='', |
| is_phase_field=False, |
| is_restricted_field=True) |
| |
| field_helpers.ParsedFieldDefAssertions(self.mr, parsed_fd) |
| self.assertTrue(self.mr.errors.AnyErrors()) |
| |
| self.assertEqual( |
| self.mr.errors.is_niche, 'A field cannot be both required and niche.') |
| self.assertEqual( |
| self.mr.errors.date_action, |
| 'The date action should be either: ' + ', '.join( |
| config_svc.DATE_ACTION_ENUM) + '.') |
| self.assertEqual( |
| self.mr.errors.min_value, 'Minimum value must be less than maximum.') |
| self.assertEqual(self.mr.errors.regex, 'Invalid regular expression.') |
| |
| def testValidateLabels_NoLabels(self): |
| err_msg = field_helpers.ValidateLabels( |
| self.mr.cnxn, |
| self.services, |
| self.mr.project_id, [''], |
| ezt_errors=self.errors) |
| self.assertFalse(self.errors.AnyErrors()) |
| self.assertEqual(err_msg, None) |
| |
| def testValidateLabels_ExistingLabel(self): |
| err_msg = field_helpers.ValidateLabels( |
| self.mr.cnxn, |
| self.services, |
| self.mr.project_id, ['old_label'], |
| ezt_errors=self.errors) |
| self.assertFalse(self.errors.AnyErrors()) |
| self.assertEqual(err_msg, None) |
| |
| def testValidateLabels_AllowlistedLabel(self): |
| err_msg = field_helpers.ValidateLabels( |
| self.mr.cnxn, |
| self.services, |
| self.mr.project_id, ['old_label', 'CVE-test'], |
| ezt_errors=self.errors) |
| self.assertFalse(self.errors.AnyErrors()) |
| self.assertEqual(err_msg, None) |
| |
| def testValidateLabels_Error(self): |
| err_msg = field_helpers.ValidateLabels( |
| self.mr.cnxn, |
| self.services, |
| self.mr.project_id, ['freeze_new_label'], |
| ezt_errors=self.errors) |
| self.assertTrue(self.errors.AnyErrors()) |
| self.assertEqual( |
| err_msg, ( |
| 'The creation of new labels is blocked for the Chromium project' |
| ' in Monorail. To continue with editing your issue, please' |
| ' remove: freeze_new_label label(s).')) |