| #!/usr/bin/env python3 |
| # Copyright 2016 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """Unittests for the hooks module.""" |
| |
| import os |
| import sys |
| import unittest |
| from unittest import mock |
| |
| _path = os.path.realpath(__file__ + '/../..') |
| if sys.path[0] != _path: |
| sys.path.insert(0, _path) |
| del _path |
| |
| # We have to import our local modules after the sys.path tweak. We can't use |
| # relative imports because this is an executable program, not a module. |
| # pylint: disable=wrong-import-position |
| import rh |
| import rh.config |
| import rh.hooks |
| |
| |
| # pylint: disable=unused-argument |
| def mock_find_repo_root(path=None, outer=False): |
| return '/ ${BUILD_OS}' if outer else '/ ${BUILD_OS}/sub' |
| |
| |
| class HooksDocsTests(unittest.TestCase): |
| """Make sure all hook features are documented. |
| |
| Note: These tests are a bit hokey in that they parse README.md. But they |
| get the job done, so that's all that matters right? |
| """ |
| |
| def setUp(self): |
| self.readme = os.path.join(os.path.dirname(os.path.dirname( |
| os.path.realpath(__file__))), 'README.md') |
| |
| def _grab_section(self, section): |
| """Extract the |section| text out of the readme.""" |
| ret = [] |
| in_section = False |
| with open(self.readme, encoding='utf-8') as fp: |
| for line in fp: |
| if not in_section: |
| # Look for the section like "## [Tool Paths]". |
| if (line.startswith('#') and |
| line.lstrip('#').strip() == section): |
| in_section = True |
| else: |
| # Once we hit the next section (higher or lower), break. |
| if line[0] == '#': |
| break |
| ret.append(line) |
| return ''.join(ret) |
| |
| def testBuiltinHooks(self): |
| """Verify builtin hooks are documented.""" |
| data = self._grab_section('[Builtin Hooks]') |
| for hook in rh.hooks.BUILTIN_HOOKS: |
| self.assertIn(f'* `{hook}`:', data, |
| msg=f'README.md missing docs for hook "{hook}"') |
| |
| def testToolPaths(self): |
| """Verify tools are documented.""" |
| data = self._grab_section('[Tool Paths]') |
| for tool in rh.hooks.TOOL_PATHS: |
| self.assertIn(f'* `{tool}`:', data, |
| msg=f'README.md missing docs for tool "{tool}"') |
| |
| def testPlaceholders(self): |
| """Verify placeholder replacement vars are documented.""" |
| data = self._grab_section('Placeholders') |
| for var in rh.hooks.Placeholders.vars(): |
| self.assertIn('* `${' + var + '}`:', data, |
| msg=f'README.md missing docs for var "{var}"') |
| |
| |
| class PlaceholderTests(unittest.TestCase): |
| """Verify behavior of replacement variables.""" |
| |
| def setUp(self): |
| self._saved_environ = os.environ.copy() |
| os.environ.update({ |
| 'PREUPLOAD_COMMIT_MESSAGE': 'commit message', |
| 'PREUPLOAD_COMMIT': '5c4c293174bb61f0f39035a71acd9084abfa743d', |
| }) |
| self.replacer = rh.hooks.Placeholders( |
| [rh.git.RawDiffEntry(file=x) |
| for x in ['path1/file1', 'path2/file2']]) |
| |
| def tearDown(self): |
| os.environ.clear() |
| os.environ.update(self._saved_environ) |
| |
| def testVars(self): |
| """Light test for the vars inspection generator.""" |
| ret = list(self.replacer.vars()) |
| self.assertGreater(len(ret), 4) |
| self.assertIn('PREUPLOAD_COMMIT', ret) |
| |
| @mock.patch.object(rh.git, 'find_repo_root', |
| side_effect=mock_find_repo_root) |
| def testExpandVars(self, _m): |
| """Verify the replacement actually works.""" |
| input_args = [ |
| # Verify ${REPO_ROOT} is updated, but not REPO_ROOT. |
| # We also make sure that things in ${REPO_ROOT} are not double |
| # expanded (which is why the return includes ${BUILD_OS}). |
| '${REPO_ROOT}/some/prog/REPO_ROOT/ok', |
| # Verify that ${REPO_OUTER_ROOT} is expanded. |
| '${REPO_OUTER_ROOT}/some/prog/REPO_OUTER_ROOT/ok', |
| # Verify lists are merged rather than inserted. |
| '${PREUPLOAD_FILES}', |
| # Verify each file is preceded with '--file=' prefix. |
| '--file=${PREUPLOAD_FILES_PREFIXED}', |
| # Verify each file is preceded with '--file' argument. |
| '--file', |
| '${PREUPLOAD_FILES_PREFIXED}', |
| # Verify values with whitespace don't expand into multiple args. |
| '${PREUPLOAD_COMMIT_MESSAGE}', |
| # Verify multiple values get replaced. |
| '${PREUPLOAD_COMMIT}^${PREUPLOAD_COMMIT_MESSAGE}', |
| # Unknown vars should be left alone. |
| '${THIS_VAR_IS_GOOD}', |
| ] |
| output_args = self.replacer.expand_vars(input_args) |
| exp_args = [ |
| '/ ${BUILD_OS}/sub/some/prog/REPO_ROOT/ok', |
| '/ ${BUILD_OS}/some/prog/REPO_OUTER_ROOT/ok', |
| 'path1/file1', |
| 'path2/file2', |
| '--file=path1/file1', |
| '--file=path2/file2', |
| '--file', |
| 'path1/file1', |
| '--file', |
| 'path2/file2', |
| 'commit message', |
| '5c4c293174bb61f0f39035a71acd9084abfa743d^commit message', |
| '${THIS_VAR_IS_GOOD}', |
| ] |
| self.assertEqual(output_args, exp_args) |
| |
| def testTheTester(self): |
| """Make sure we have a test for every variable.""" |
| for var in self.replacer.vars(): |
| self.assertIn(f'test{var}', dir(self), |
| msg=f'Missing unittest for variable {var}') |
| |
| def testPREUPLOAD_COMMIT_MESSAGE(self): |
| """Verify handling of PREUPLOAD_COMMIT_MESSAGE.""" |
| self.assertEqual(self.replacer.get('PREUPLOAD_COMMIT_MESSAGE'), |
| 'commit message') |
| |
| def testPREUPLOAD_COMMIT(self): |
| """Verify handling of PREUPLOAD_COMMIT.""" |
| self.assertEqual(self.replacer.get('PREUPLOAD_COMMIT'), |
| '5c4c293174bb61f0f39035a71acd9084abfa743d') |
| |
| def testPREUPLOAD_FILES(self): |
| """Verify handling of PREUPLOAD_FILES.""" |
| self.assertEqual(self.replacer.get('PREUPLOAD_FILES'), |
| ['path1/file1', 'path2/file2']) |
| |
| @mock.patch.object(rh.git, 'find_repo_root') |
| def testREPO_OUTER_ROOT(self, m): |
| """Verify handling of REPO_OUTER_ROOT.""" |
| m.side_effect = mock_find_repo_root |
| self.assertEqual(self.replacer.get('REPO_OUTER_ROOT'), |
| mock_find_repo_root(path=None, outer=True)) |
| |
| @mock.patch.object(rh.git, 'find_repo_root') |
| def testREPO_ROOT(self, m): |
| """Verify handling of REPO_ROOT.""" |
| m.side_effect = mock_find_repo_root |
| self.assertEqual(self.replacer.get('REPO_ROOT'), |
| mock_find_repo_root(path=None, outer=False)) |
| |
| def testREPO_PATH(self): |
| """Verify handling of REPO_PATH.""" |
| os.environ['REPO_PATH'] = '' |
| self.assertEqual(self.replacer.get('REPO_PATH'), '') |
| os.environ['REPO_PATH'] = 'foo/bar' |
| self.assertEqual(self.replacer.get('REPO_PATH'), 'foo/bar') |
| |
| def testREPO_PROJECT(self): |
| """Verify handling of REPO_PROJECT.""" |
| os.environ['REPO_PROJECT'] = '' |
| self.assertEqual(self.replacer.get('REPO_PROJECT'), '') |
| os.environ['REPO_PROJECT'] = 'platform/foo/bar' |
| self.assertEqual(self.replacer.get('REPO_PROJECT'), 'platform/foo/bar') |
| |
| @mock.patch.object(rh.hooks, '_get_build_os_name', return_value='vapier os') |
| def testBUILD_OS(self, m): |
| """Verify handling of BUILD_OS.""" |
| self.assertEqual(self.replacer.get('BUILD_OS'), m.return_value) |
| |
| |
| class ExclusionScopeTests(unittest.TestCase): |
| """Verify behavior of ExclusionScope class.""" |
| |
| def testEmpty(self): |
| """Verify the in operator for an empty scope.""" |
| scope = rh.hooks.ExclusionScope([]) |
| self.assertNotIn('external/*', scope) |
| |
| def testGlob(self): |
| """Verify the in operator for a scope using wildcards.""" |
| scope = rh.hooks.ExclusionScope(['vendor/*', 'external/*']) |
| self.assertIn('external/tools', scope) |
| |
| def testRegex(self): |
| """Verify the in operator for a scope using regular expressions.""" |
| scope = rh.hooks.ExclusionScope(['^vendor/(?!google)', |
| 'external/*']) |
| self.assertIn('vendor/', scope) |
| self.assertNotIn('vendor/google/', scope) |
| self.assertIn('vendor/other/', scope) |
| |
| |
| class HookOptionsTests(unittest.TestCase): |
| """Verify behavior of HookOptions object.""" |
| |
| @mock.patch.object(rh.hooks, '_get_build_os_name', return_value='vapier os') |
| def testExpandVars(self, m): |
| """Verify expand_vars behavior.""" |
| # Simple pass through. |
| args = ['who', 'goes', 'there ?'] |
| self.assertEqual(args, rh.hooks.HookOptions.expand_vars(args)) |
| |
| # At least one replacement. Most real testing is in PlaceholderTests. |
| args = ['who', 'goes', 'there ?', '${BUILD_OS} is great'] |
| exp_args = ['who', 'goes', 'there ?', f'{m.return_value} is great'] |
| self.assertEqual(exp_args, rh.hooks.HookOptions.expand_vars(args)) |
| |
| def testArgs(self): |
| """Verify args behavior.""" |
| # Verify initial args to __init__ has higher precedent. |
| args = ['start', 'args'] |
| options = rh.hooks.HookOptions('hook name', args, {}) |
| self.assertEqual(options.args(), args) |
| self.assertEqual(options.args(default_args=['moo']), args) |
| |
| # Verify we fall back to default_args. |
| args = ['default', 'args'] |
| options = rh.hooks.HookOptions('hook name', [], {}) |
| self.assertEqual(options.args(), []) |
| self.assertEqual(options.args(default_args=args), args) |
| |
| def testToolPath(self): |
| """Verify tool_path behavior.""" |
| options = rh.hooks.HookOptions('hook name', [], { |
| 'cpplint': 'my cpplint', |
| }) |
| # Check a builtin (and not overridden) tool. |
| self.assertEqual(options.tool_path('pylint'), 'pylint') |
| # Check an overridden tool. |
| self.assertEqual(options.tool_path('cpplint'), 'my cpplint') |
| # Check an unknown tool fails. |
| self.assertRaises(AssertionError, options.tool_path, 'extra_tool') |
| |
| |
| class UtilsTests(unittest.TestCase): |
| """Verify misc utility functions.""" |
| |
| def testRunCommand(self): |
| """Check _run behavior.""" |
| # Most testing is done against the utils.RunCommand already. |
| # pylint: disable=protected-access |
| ret = rh.hooks._run(['true']) |
| self.assertEqual(ret.returncode, 0) |
| |
| def testBuildOs(self): |
| """Check _get_build_os_name behavior.""" |
| # Just verify it returns something and doesn't crash. |
| # pylint: disable=protected-access |
| ret = rh.hooks._get_build_os_name() |
| self.assertTrue(isinstance(ret, str)) |
| self.assertNotEqual(ret, '') |
| |
| def testGetHelperPath(self): |
| """Check get_helper_path behavior.""" |
| # Just verify it doesn't crash. It's a dirt simple func. |
| ret = rh.hooks.get_helper_path('booga') |
| self.assertTrue(isinstance(ret, str)) |
| self.assertNotEqual(ret, '') |
| |
| def testSortedToolPaths(self): |
| """Check TOOL_PATHS is sorted.""" |
| # This assumes dictionary key ordering matches insertion/definition |
| # order which Python 3.7+ has codified. |
| # https://docs.python.org/3.7/library/stdtypes.html#dict |
| self.assertEqual(list(rh.hooks.TOOL_PATHS), sorted(rh.hooks.TOOL_PATHS)) |
| |
| def testSortedBuiltinHooks(self): |
| """Check BUILTIN_HOOKS is sorted.""" |
| # This assumes dictionary key ordering matches insertion/definition |
| # order which Python 3.7+ has codified. |
| # https://docs.python.org/3.7/library/stdtypes.html#dict |
| self.assertEqual( |
| list(rh.hooks.BUILTIN_HOOKS), sorted(rh.hooks.BUILTIN_HOOKS)) |
| |
| |
| @mock.patch.object(rh.utils, 'run') |
| @mock.patch.object(rh.hooks, '_check_cmd', return_value=['check_cmd']) |
| class BuiltinHooksTests(unittest.TestCase): |
| """Verify the builtin hooks.""" |
| |
| def setUp(self): |
| self.project = rh.Project(name='project-name', dir='/.../repo/dir') |
| self.options = rh.hooks.HookOptions('hook name', [], {}) |
| |
| def _test_commit_messages(self, func, accept, msgs, files=None): |
| """Helper for testing commit message hooks. |
| |
| Args: |
| func: The hook function to test. |
| accept: Whether all the |msgs| should be accepted. |
| msgs: List of messages to test. |
| files: List of files to pass to the hook. |
| """ |
| if files: |
| diff = [rh.git.RawDiffEntry(file=x) for x in files] |
| else: |
| diff = [] |
| for desc in msgs: |
| ret = func(self.project, 'commit', desc, diff, options=self.options) |
| if accept: |
| self.assertFalse( |
| bool(ret), msg='Should have accepted: {{{' + desc + '}}}') |
| else: |
| self.assertTrue( |
| bool(ret), msg='Should have rejected: {{{' + desc + '}}}') |
| |
| def _test_file_filter(self, mock_check, func, files): |
| """Helper for testing hooks that filter by files and run external tools. |
| |
| Args: |
| mock_check: The mock of _check_cmd. |
| func: The hook function to test. |
| files: A list of files that we'd check. |
| """ |
| # First call should do nothing as there are no files to check. |
| ret = func(self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| |
| # Second call should include some checks. |
| diff = [rh.git.RawDiffEntry(file=x) for x in files] |
| ret = func(self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertEqual(ret, mock_check.return_value) |
| |
| def testTheTester(self, _mock_check, _mock_run): |
| """Make sure we have a test for every hook.""" |
| for hook in rh.hooks.BUILTIN_HOOKS: |
| self.assertIn(f'test_{hook}', dir(self), |
| msg=f'Missing unittest for builtin hook {hook}') |
| |
| def test_aosp_license(self, mock_check, _mock_run): |
| """Verify the aosp_license builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| diff = [ |
| rh.git.RawDiffEntry(file='d.bp', status='D'), |
| rh.git.RawDiffEntry(file='m.bp', status='M'), |
| rh.git.RawDiffEntry(file='non-interested', status='A'), |
| ] |
| ret = rh.hooks.check_aosp_license( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| |
| # Second call will have some results. |
| diff = [ |
| rh.git.RawDiffEntry(file='a.bp', status='A'), |
| ] |
| ret = rh.hooks.check_aosp_license( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertIsNotNone(ret) |
| |
| # No result since all paths are excluded. |
| diff = [ |
| rh.git.RawDiffEntry(file='a/a.bp', status='A'), |
| rh.git.RawDiffEntry(file='b/a.bp', status='A'), |
| rh.git.RawDiffEntry(file='c/d/a.bp', status='A'), |
| ] |
| ret = rh.hooks.check_aosp_license( |
| self.project, 'commit', 'desc', diff, |
| options=rh.hooks.HookOptions('hook name', |
| ['--exclude-dirs=a,b', '--exclude-dirs=c/d'], {}) |
| ) |
| self.assertIsNone(ret) |
| |
| # Make sure that `--exclude-dir` doesn't match the path in the middle. |
| diff = [ |
| rh.git.RawDiffEntry(file='a/b/c.bp', status='A'), |
| ] |
| ret = rh.hooks.check_aosp_license( |
| self.project, 'commit', 'desc', diff, |
| options=rh.hooks.HookOptions('hook name', ['--exclude-dirs=b'], {}) |
| ) |
| self.assertIsNotNone(ret) |
| |
| |
| def test_bpfmt(self, mock_check, _mock_run): |
| """Verify the bpfmt builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_bpfmt( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| |
| # Second call will have some results. |
| diff = [rh.git.RawDiffEntry(file='Android.bp')] |
| ret = rh.hooks.check_bpfmt( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertIsNotNone(ret) |
| for result in ret: |
| self.assertIsNotNone(result.fixup_cmd) |
| |
| def test_checkpatch(self, mock_check, _mock_run): |
| """Verify the checkpatch builtin hook.""" |
| ret = rh.hooks.check_checkpatch( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertEqual(ret, mock_check.return_value) |
| |
| def test_clang_format(self, mock_check, _mock_run): |
| """Verify the clang_format builtin hook.""" |
| ret = rh.hooks.check_clang_format( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertEqual(ret, mock_check.return_value) |
| |
| def test_google_java_format(self, mock_check, _mock_run): |
| """Verify the google_java_format builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_google_java_format( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| # Check that .java files are included by default. |
| diff = [rh.git.RawDiffEntry(file='foo.java'), |
| rh.git.RawDiffEntry(file='bar.kt'), |
| rh.git.RawDiffEntry(file='baz/blah.java')] |
| ret = rh.hooks.check_google_java_format( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertListEqual(ret[0].files, ['foo.java', 'baz/blah.java']) |
| diff = [rh.git.RawDiffEntry(file='foo/f1.java'), |
| rh.git.RawDiffEntry(file='bar/f2.java'), |
| rh.git.RawDiffEntry(file='baz/f2.java')] |
| ret = rh.hooks.check_google_java_format( |
| self.project, 'commit', 'desc', diff, |
| options=rh.hooks.HookOptions('hook name', |
| ['--include-dirs=foo,baz'], {})) |
| self.assertListEqual(ret[0].files, ['foo/f1.java', 'baz/f2.java']) |
| |
| def test_commit_msg_bug_field(self, _mock_check, _mock_run): |
| """Verify the commit_msg_bug_field builtin hook.""" |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_bug_field, True, ( |
| 'subj\n\nBug: 1234\n', |
| 'subj\n\nBug: 1234\nChange-Id: blah\n', |
| 'subj\n\nFix: 1234\n', |
| )) |
| |
| # Check some bad messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_bug_field, False, ( |
| 'subj', |
| 'subj\n\nBUG=1234\n', |
| 'subj\n\nBUG: 1234\n', |
| 'subj\n\nBug: N/A\n', |
| 'subj\n\nBug:\n', |
| 'subj\n\nFIX=1234\n', |
| )) |
| |
| def test_commit_msg_changeid_field(self, _mock_check, _mock_run): |
| """Verify the commit_msg_changeid_field builtin hook.""" |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_changeid_field, True, ( |
| 'subj\n\nChange-Id: I1234\n', |
| )) |
| |
| # Check some bad messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_changeid_field, False, ( |
| 'subj', |
| 'subj\n\nChange-Id: 1234\n', |
| 'subj\n\nChange-ID: I1234\n', |
| )) |
| |
| def test_commit_msg_prebuilt_apk_fields(self, _mock_check, _mock_run): |
| """Verify the check_commit_msg_prebuilt_apk_fields builtin hook.""" |
| # Commits without APKs should pass. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_prebuilt_apk_fields, |
| True, |
| ( |
| 'subj\nTest: test case\nBug: bug id\n', |
| ), |
| ['foo.cpp', 'bar.py',] |
| ) |
| |
| # Commits with APKs and all the required messages should pass. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_prebuilt_apk_fields, |
| True, |
| ( |
| ('Test App\n\nbar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'targetSdkVersion:\'28\'\n\nBuilt here:\n' |
| 'http://foo.bar.com/builder\n\n' |
| 'This build IS suitable for public release.\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| ('Test App\n\nBuilt here:\nhttp://foo.bar.com/builder\n\n' |
| 'This build IS NOT suitable for public release.\n\n' |
| 'bar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'targetSdkVersion:\'28\'\n\nBug: 123\nTest: test\n' |
| 'Change-Id: XXXXXXX\n'), |
| ('Test App\n\nbar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'targetSdkVersion:\'28\'\n\nBuilt here:\n' |
| 'http://foo.bar.com/builder\n\n' |
| 'This build IS suitable for preview release but IS NOT ' |
| 'suitable for public release.\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| ('Test App\n\nbar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'targetSdkVersion:\'28\'\n\nBuilt here:\n' |
| 'http://foo.bar.com/builder\n\n' |
| 'This build IS NOT suitable for preview or public release.\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| ), |
| ['foo.apk', 'bar.py',] |
| ) |
| |
| # Commits with APKs and without all the required messages should fail. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_prebuilt_apk_fields, |
| False, |
| ( |
| 'subj\nTest: test case\nBug: bug id\n', |
| # Missing 'package'. |
| ('Test App\n\nbar.apk\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'targetSdkVersion:\'28\'\n\nBuilt here:\n' |
| 'http://foo.bar.com/builder\n\n' |
| 'This build IS suitable for public release.\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| # Missing 'sdkVersion'. |
| ('Test App\n\nbar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\n' |
| 'targetSdkVersion:\'28\'\n\nBuilt here:\n' |
| 'http://foo.bar.com/builder\n\n' |
| 'This build IS suitable for public release.\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| # Missing 'targetSdkVersion'. |
| ('Test App\n\nbar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'Built here:\nhttp://foo.bar.com/builder\n\n' |
| 'This build IS suitable for public release.\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| # Missing build location. |
| ('Test App\n\nbar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'targetSdkVersion:\'28\'\n\n' |
| 'This build IS suitable for public release.\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| # Missing public release indication. |
| ('Test App\n\nbar.apk\npackage: name=\'com.foo.bar\'\n' |
| 'versionCode=\'1001\'\nversionName=\'1.0.1001-A\'\n' |
| 'platformBuildVersionName=\'\'\ncompileSdkVersion=\'28\'\n' |
| 'compileSdkVersionCodename=\'9\'\nsdkVersion:\'16\'\n' |
| 'targetSdkVersion:\'28\'\n\nBuilt here:\n' |
| 'http://foo.bar.com/builder\n\n' |
| 'Bug: 123\nTest: test\nChange-Id: XXXXXXX\n'), |
| ), |
| ['foo.apk', 'bar.py',] |
| ) |
| |
| def test_commit_msg_test_field(self, _mock_check, _mock_run): |
| """Verify the commit_msg_test_field builtin hook.""" |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_test_field, True, ( |
| 'subj\n\nTest: i did done dood it\n', |
| )) |
| |
| # Check some bad messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_test_field, False, ( |
| 'subj', |
| 'subj\n\nTEST=1234\n', |
| 'subj\n\nTEST: I1234\n', |
| )) |
| |
| def test_commit_msg_relnote_field_format(self, _mock_check, _mock_run): |
| """Verify the commit_msg_relnote_field_format builtin hook.""" |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_field_format, |
| True, |
| ( |
| 'subj', |
| 'subj\n\nTest: i did done dood it\nBug: 1234', |
| 'subj\n\nMore content\n\nTest: i did done dood it\nBug: 1234', |
| 'subj\n\nRelnote: This is a release note\nBug: 1234', |
| 'subj\n\nRelnote:This is a release note\nBug: 1234', |
| 'subj\n\nRelnote: This is a release note.\nBug: 1234', |
| 'subj\n\nRelnote: "This is a release note."\nBug: 1234', |
| 'subj\n\nRelnote: "This is a \\"release note\\"."\n\nBug: 1234', |
| 'subj\n\nRelnote: This is a release note.\nChange-Id: 1234', |
| 'subj\n\nRelnote: This is a release note.\n\nChange-Id: 1234', |
| ('subj\n\nRelnote: "This is a release note."\n\n' |
| 'Change-Id: 1234'), |
| ('subj\n\nRelnote: This is a release note.\n\n' |
| 'It has more info, but it is not part of the release note' |
| '\nChange-Id: 1234'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| 'It contains a correct second line."'), |
| ('subj\n\nRelnote:"This is a release note.\n' |
| 'It contains a correct second line."'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| 'It contains a correct second line.\n' |
| 'And even a third line."\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| 'It contains a correct second line.\n' |
| '\\"Quotes\\" are even used on the third line."\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: This is release note 1.\n' |
| 'Relnote: This is release note 2.\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: This is release note 1.\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains a correctly formatted third line."\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: "This is release note 1 with\n' |
| 'a correctly formatted second line."\n\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains a correctly formatted second line."\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: "This is a release note with\n' |
| 'a correctly formatted second line."\n\n' |
| 'Bug: 1234' |
| 'Here is some extra "quoted" content.'), |
| ('subj\n\nRelnote: """This is a release note.\n\n' |
| 'This relnote contains an empty line.\n' |
| 'Then a non-empty line.\n\n' |
| 'And another empty line."""\n\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: """This is a release note.\n\n' |
| 'This relnote contains an empty line.\n' |
| 'Then an acceptable "quoted" line.\n\n' |
| 'And another empty line."""\n\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: """This is a release note."""\n\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: """This is a release note.\n' |
| 'It has a second line."""\n\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: """This is a release note.\n' |
| 'It has a second line, but does not end here.\n' |
| '"""\n\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: """This is a release note.\n' |
| '"It" has a second line, but does not end here.\n' |
| '"""\n\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| 'It has a second line, but does not end here.\n' |
| '"\n\n' |
| 'Bug: 1234'), |
| )) |
| |
| # Check some bad messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_field_format, |
| False, |
| ( |
| 'subj\n\nReleaseNote: This is a release note.\n', |
| 'subj\n\nRelnotes: This is a release note.\n', |
| 'subj\n\nRel-note: This is a release note.\n', |
| 'subj\n\nrelnoTes: This is a release note.\n', |
| 'subj\n\nrel-Note: This is a release note.\n', |
| 'subj\n\nRelnote: "This is a "release note"."\nBug: 1234', |
| 'subj\n\nRelnote: This is a "release note".\nBug: 1234', |
| ('subj\n\nRelnote: This is a release note.\n' |
| 'It contains an incorrect second line.'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| 'It contains multiple lines.\n' |
| 'But it does not provide an ending quote.\n'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| 'It contains multiple lines but no closing quote.\n' |
| 'Test: my test "hello world"\n'), |
| ('subj\n\nRelnote: This is release note 1.\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains an incorrectly formatted third line.\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: This is release note 1 with\n' |
| 'an incorrectly formatted second line.\n\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains a correctly formatted second line."\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: "This is release note 1 with\n' |
| 'a correctly formatted second line."\n\n' |
| 'Relnote: This is release note 2, and it\n' |
| 'contains an incorrectly formatted second line.\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| 'It contains a correct second line.\n' |
| 'But incorrect "quotes" on the third line."\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: """This is a release note.\n' |
| 'It has a second line, but no closing triple quote.\n\n' |
| 'Bug: 1234'), |
| ('subj\n\nRelnote: "This is a release note.\n' |
| '"It" has a second line, but does not end here.\n' |
| '"\n\n' |
| 'Bug: 1234'), |
| )) |
| |
| def test_commit_msg_relnote_for_current_txt(self, _mock_check, _mock_run): |
| """Verify the commit_msg_relnote_for_current_txt builtin hook.""" |
| diff_without_current_txt = ['bar/foo.txt', |
| 'foo.cpp', |
| 'foo.java', |
| 'foo_current.java', |
| 'foo_current.txt', |
| 'baz/current.java', |
| 'baz/foo_current.txt'] |
| diff_with_current_txt = diff_without_current_txt + ['current.txt'] |
| diff_with_subdir_current_txt = \ |
| diff_without_current_txt + ['foo/current.txt'] |
| diff_with_experimental_current_txt = \ |
| diff_without_current_txt + ['public_plus_experimental_current.txt'] |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_for_current_txt, |
| True, |
| ( |
| 'subj\n\nRelnote: This is a release note\n', |
| 'subj\n\nRelnote: This is a release note.\n\nChange-Id: 1234', |
| ('subj\n\nRelnote: This is release note 1 with\n' |
| 'an incorrectly formatted second line.\n\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains a correctly formatted second line."\n' |
| 'Bug: 1234'), |
| ), |
| files=diff_with_current_txt, |
| ) |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_for_current_txt, |
| True, |
| ( |
| 'subj\n\nRelnote: This is a release note\n', |
| 'subj\n\nRelnote: This is a release note.\n\nChange-Id: 1234', |
| ('subj\n\nRelnote: This is release note 1 with\n' |
| 'an incorrectly formatted second line.\n\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains a correctly formatted second line."\n' |
| 'Bug: 1234'), |
| ), |
| files=diff_with_experimental_current_txt, |
| ) |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_for_current_txt, |
| True, |
| ( |
| 'subj\n\nRelnote: This is a release note\n', |
| 'subj\n\nRelnote: This is a release note.\n\nChange-Id: 1234', |
| ('subj\n\nRelnote: This is release note 1 with\n' |
| 'an incorrectly formatted second line.\n\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains a correctly formatted second line."\n' |
| 'Bug: 1234'), |
| ), |
| files=diff_with_subdir_current_txt, |
| ) |
| # Check some good messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_for_current_txt, |
| True, |
| ( |
| 'subj', |
| 'subj\nBug: 12345\nChange-Id: 1234', |
| 'subj\n\nRelnote: This is a release note\n', |
| 'subj\n\nRelnote: This is a release note.\n\nChange-Id: 1234', |
| ('subj\n\nRelnote: This is release note 1 with\n' |
| 'an incorrectly formatted second line.\n\n' |
| 'Relnote: "This is release note 2, and it\n' |
| 'contains a correctly formatted second line."\n' |
| 'Bug: 1234'), |
| ), |
| files=diff_without_current_txt, |
| ) |
| # Check some bad messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_for_current_txt, |
| False, |
| ( |
| 'subj' |
| 'subj\nBug: 12345\nChange-Id: 1234', |
| ), |
| files=diff_with_current_txt, |
| ) |
| # Check some bad messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_for_current_txt, |
| False, |
| ( |
| 'subj' |
| 'subj\nBug: 12345\nChange-Id: 1234', |
| ), |
| files=diff_with_experimental_current_txt, |
| ) |
| # Check some bad messages. |
| self._test_commit_messages( |
| rh.hooks.check_commit_msg_relnote_for_current_txt, |
| False, |
| ( |
| 'subj' |
| 'subj\nBug: 12345\nChange-Id: 1234', |
| ), |
| files=diff_with_subdir_current_txt, |
| ) |
| |
| def test_cpplint(self, mock_check, _mock_run): |
| """Verify the cpplint builtin hook.""" |
| self._test_file_filter(mock_check, rh.hooks.check_cpplint, |
| ('foo.cpp', 'foo.cxx')) |
| |
| def test_gofmt(self, mock_check, _mock_run): |
| """Verify the gofmt builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_gofmt( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| |
| # Second call will have some results. |
| diff = [rh.git.RawDiffEntry(file='foo.go')] |
| ret = rh.hooks.check_gofmt( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertIsNotNone(ret) |
| |
| def test_jsonlint(self, mock_check, _mock_run): |
| """Verify the jsonlint builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_json( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| |
| # TODO: Actually pass some valid/invalid json data down. |
| |
| def test_ktfmt(self, mock_check, _mock_run): |
| """Verify the ktfmt builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_ktfmt( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| # Check that .kt files are included by default. |
| diff = [rh.git.RawDiffEntry(file='foo.kt'), |
| rh.git.RawDiffEntry(file='bar.java'), |
| rh.git.RawDiffEntry(file='baz/blah.kt')] |
| ret = rh.hooks.check_ktfmt( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertListEqual(ret[0].files, ['foo.kt', 'baz/blah.kt']) |
| diff = [rh.git.RawDiffEntry(file='foo/f1.kt'), |
| rh.git.RawDiffEntry(file='bar/f2.kt'), |
| rh.git.RawDiffEntry(file='baz/f2.kt')] |
| ret = rh.hooks.check_ktfmt(self.project, 'commit', 'desc', diff, |
| options=rh.hooks.HookOptions('hook name', [ |
| '--include-dirs=foo,baz'], {})) |
| self.assertListEqual(ret[0].files, ['foo/f1.kt', 'baz/f2.kt']) |
| |
| def test_pylint(self, mock_check, _mock_run): |
| """Verify the pylint builtin hook.""" |
| self._test_file_filter(mock_check, rh.hooks.check_pylint2, |
| ('foo.py',)) |
| |
| def test_pylint2(self, mock_check, _mock_run): |
| """Verify the pylint2 builtin hook.""" |
| self._test_file_filter(mock_check, rh.hooks.check_pylint2, |
| ('foo.py',)) |
| |
| def test_pylint3(self, mock_check, _mock_run): |
| """Verify the pylint3 builtin hook.""" |
| self._test_file_filter(mock_check, rh.hooks.check_pylint3, |
| ('foo.py',)) |
| |
| def test_rustfmt(self, mock_check, _mock_run): |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_rustfmt( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertEqual(ret, None) |
| self.assertFalse(mock_check.called) |
| |
| # Second call will have some results. |
| diff = [rh.git.RawDiffEntry(file='lib.rs')] |
| ret = rh.hooks.check_rustfmt( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertNotEqual(ret, None) |
| |
| def test_xmllint(self, mock_check, _mock_run): |
| """Verify the xmllint builtin hook.""" |
| self._test_file_filter(mock_check, rh.hooks.check_xmllint, |
| ('foo.xml',)) |
| |
| def test_android_test_mapping_format(self, mock_check, _mock_run): |
| """Verify the android_test_mapping_format builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_android_test_mapping( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| |
| # Second call will have some results. |
| diff = [rh.git.RawDiffEntry(file='TEST_MAPPING')] |
| ret = rh.hooks.check_android_test_mapping( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertIsNotNone(ret) |
| |
| def test_aidl_format(self, mock_check, _mock_run): |
| """Verify the aidl_format builtin hook.""" |
| # First call should do nothing as there are no files to check. |
| ret = rh.hooks.check_aidl_format( |
| self.project, 'commit', 'desc', (), options=self.options) |
| self.assertIsNone(ret) |
| self.assertFalse(mock_check.called) |
| |
| # Second call will have some results. |
| diff = [rh.git.RawDiffEntry(file='IFoo.go')] |
| ret = rh.hooks.check_gofmt( |
| self.project, 'commit', 'desc', diff, options=self.options) |
| self.assertIsNotNone(ret) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
