Prathmesh Prabhu | c525465 | 2016-12-22 12:58:05 -0800 | [diff] [blame] | 1 | #!/usr/bin/env python2 |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 2 | # -*- coding: utf-8 -*- |
| 3 | # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| 4 | # Use of this source code is governed by a BSD-style license that can be |
| 5 | # found in the LICENSE file. |
| 6 | |
Mike Frysinger | ae40952 | 2014-02-01 03:16:11 -0500 | [diff] [blame] | 7 | """Unittests for pre-upload.py.""" |
| 8 | |
Mike Frysinger | 09d6a3d | 2013-10-08 22:21:03 -0400 | [diff] [blame] | 9 | from __future__ import print_function |
| 10 | |
David James | c3b68b3 | 2013-04-03 09:17:03 -0700 | [diff] [blame] | 11 | import os |
| 12 | import sys |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 13 | |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 14 | import errors |
| 15 | |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 16 | # pylint: disable=W0212 |
Mike Frysinger | 65d93c1 | 2014-02-01 02:59:46 -0500 | [diff] [blame] | 17 | # We access private members of the pre_upload module all over the place. |
| 18 | |
Mike Frysinger | 55f85b5 | 2014-12-18 14:45:21 -0500 | [diff] [blame] | 19 | # Make sure we can find the chromite paths. |
| 20 | sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), |
| 21 | '..', '..')) |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 22 | |
Mike Frysinger | 55f85b5 | 2014-12-18 14:45:21 -0500 | [diff] [blame] | 23 | from chromite.cbuildbot import constants |
Mike Frysinger | 65d93c1 | 2014-02-01 02:59:46 -0500 | [diff] [blame] | 24 | from chromite.lib import cros_test_lib |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 25 | from chromite.lib import git |
Daniel Erat | a350fd3 | 2014-09-29 14:02:34 -0700 | [diff] [blame] | 26 | from chromite.lib import osutils |
Mike Frysinger | 65d93c1 | 2014-02-01 02:59:46 -0500 | [diff] [blame] | 27 | |
Mike Frysinger | 55f85b5 | 2014-12-18 14:45:21 -0500 | [diff] [blame] | 28 | # Needs to be after chromite imports so we use the bundled copy. |
| 29 | import mock |
| 30 | |
Mike Frysinger | 65d93c1 | 2014-02-01 02:59:46 -0500 | [diff] [blame] | 31 | |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 32 | pre_upload = __import__('pre-upload') |
| 33 | |
| 34 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 35 | def ProjectNamed(project_name): |
| 36 | """Wrapper to create a Project with just the name""" |
| 37 | return pre_upload.Project(project_name, None, None) |
| 38 | |
| 39 | |
Mike Frysinger | 65d93c1 | 2014-02-01 02:59:46 -0500 | [diff] [blame] | 40 | class TryUTF8DecodeTest(cros_test_lib.TestCase): |
Mike Frysinger | ae40952 | 2014-02-01 03:16:11 -0500 | [diff] [blame] | 41 | """Verify we sanely handle unicode content.""" |
| 42 | |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 43 | def runTest(self): |
| 44 | self.assertEquals(u'', pre_upload._try_utf8_decode('')) |
| 45 | self.assertEquals(u'abc', pre_upload._try_utf8_decode('abc')) |
Daniel Erat | 9d203ff | 2015-02-17 10:12:21 -0700 | [diff] [blame] | 46 | self.assertEquals( |
| 47 | u'ä½ å¥½å¸èæ©', |
| 48 | pre_upload._try_utf8_decode('ä½ å¥½å¸èæ©')) |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 49 | # Invalid UTF-8 |
| 50 | self.assertEquals('\x80', pre_upload._try_utf8_decode('\x80')) |
| 51 | |
| 52 | |
Mike Frysinger | 1459d36 | 2014-12-06 13:53:23 -0500 | [diff] [blame] | 53 | class CheckNoLongLinesTest(cros_test_lib.MockTestCase): |
Mike Frysinger | ae40952 | 2014-02-01 03:16:11 -0500 | [diff] [blame] | 54 | """Tests for _check_no_long_lines.""" |
| 55 | |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 56 | def setUp(self): |
Mike Frysinger | 1459d36 | 2014-12-06 13:53:23 -0500 | [diff] [blame] | 57 | self.diff_mock = self.PatchObject(pre_upload, '_get_file_diff') |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 58 | |
Shuhei Takahashi | abc20f3 | 2017-07-10 19:35:45 +0900 | [diff] [blame] | 59 | def testCheck(self): |
| 60 | self.PatchObject(pre_upload, '_get_affected_files', return_value=['x.py']) |
Mike Frysinger | 1459d36 | 2014-12-06 13:53:23 -0500 | [diff] [blame] | 61 | self.diff_mock.return_value = [ |
| 62 | (1, u"x" * 80), # OK |
| 63 | (2, "\x80" * 80), # OK |
| 64 | (3, u"x" * 81), # Too long |
| 65 | (4, "\x80" * 81), # Too long |
| 66 | (5, u"See http://" + (u"x" * 80)), # OK (URL) |
| 67 | (6, u"See https://" + (u"x" * 80)), # OK (URL) |
| 68 | (7, u"# define " + (u"x" * 80)), # OK (compiler directive) |
| 69 | (8, u"#define" + (u"x" * 74)), # Too long |
| 70 | ] |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 71 | failure = pre_upload._check_no_long_lines(ProjectNamed('PROJECT'), 'COMMIT') |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 72 | self.assertTrue(failure) |
| 73 | self.assertEquals('Found lines longer than 80 characters (first 5 shown):', |
| 74 | failure.msg) |
| 75 | self.assertEquals(['x.py, line %d, 81 chars' % line |
| 76 | for line in [3, 4, 8]], |
| 77 | failure.items) |
| 78 | |
Shuhei Takahashi | abc20f3 | 2017-07-10 19:35:45 +0900 | [diff] [blame] | 79 | def testIncludeOptions(self): |
| 80 | self.PatchObject(pre_upload, |
| 81 | '_get_affected_files', |
| 82 | return_value=['foo.txt']) |
| 83 | self.diff_mock.return_value = [(1, u"x" * 81)] |
| 84 | self.assertFalse(pre_upload._check_no_long_lines( |
| 85 | ProjectNamed('PROJECT'), 'COMMIT')) |
| 86 | self.assertTrue(pre_upload._check_no_long_lines( |
| 87 | ProjectNamed('PROJECT'), 'COMMIT', options=['--include_regex=foo'])) |
| 88 | |
| 89 | def testExcludeOptions(self): |
| 90 | self.PatchObject(pre_upload, |
| 91 | '_get_affected_files', |
| 92 | return_value=['foo.py']) |
| 93 | self.diff_mock.return_value = [(1, u"x" * 81)] |
| 94 | self.assertTrue(pre_upload._check_no_long_lines( |
| 95 | ProjectNamed('PROJECT'), 'COMMIT')) |
| 96 | self.assertFalse(pre_upload._check_no_long_lines( |
| 97 | ProjectNamed('PROJECT'), 'COMMIT', options=['--exclude_regex=foo'])) |
| 98 | |
Mike Frysinger | ae40952 | 2014-02-01 03:16:11 -0500 | [diff] [blame] | 99 | |
Prathmesh Prabhu | c525465 | 2016-12-22 12:58:05 -0800 | [diff] [blame] | 100 | class CheckTabbedIndentsTest(cros_test_lib.MockTestCase): |
| 101 | """Tests for _check_tabbed_indents.""" |
| 102 | def setUp(self): |
Shuhei Takahashi | abc20f3 | 2017-07-10 19:35:45 +0900 | [diff] [blame] | 103 | self.PatchObject(pre_upload, |
| 104 | '_get_affected_files', |
| 105 | return_value=['x.ebuild']) |
Prathmesh Prabhu | c525465 | 2016-12-22 12:58:05 -0800 | [diff] [blame] | 106 | self.diff_mock = self.PatchObject(pre_upload, '_get_file_diff') |
| 107 | |
| 108 | def test_good_cases(self): |
| 109 | self.diff_mock.return_value = [ |
| 110 | (1, u'no_tabs_anywhere'), |
| 111 | (2, u' leading_tab_only'), |
| 112 | (3, u' leading_tab another_tab'), |
| 113 | (4, u' leading_tab trailing_too '), |
| 114 | (5, u' leading_tab then_spaces_trailing '), |
| 115 | ] |
| 116 | failure = pre_upload._check_tabbed_indents(ProjectNamed('PROJECT'), |
| 117 | 'COMMIT') |
| 118 | self.assertIsNone(failure) |
| 119 | |
| 120 | def test_bad_cases(self): |
| 121 | self.diff_mock.return_value = [ |
| 122 | (1, u' leading_space'), |
| 123 | (2, u' tab_followed_by_space'), |
| 124 | (3, u' space_followed_by_tab'), |
| 125 | (4, u' mix_em_up'), |
| 126 | (5, u' mix_on_both_sides '), |
| 127 | ] |
| 128 | failure = pre_upload._check_tabbed_indents(ProjectNamed('PROJECT'), |
| 129 | 'COMMIT') |
| 130 | self.assertTrue(failure) |
| 131 | self.assertEquals('Found a space in indentation (must be all tabs):', |
| 132 | failure.msg) |
Shuhei Takahashi | abc20f3 | 2017-07-10 19:35:45 +0900 | [diff] [blame] | 133 | self.assertEquals(['x.ebuild, line %d' % line for line in xrange(1, 6)], |
Prathmesh Prabhu | c525465 | 2016-12-22 12:58:05 -0800 | [diff] [blame] | 134 | failure.items) |
| 135 | |
| 136 | |
Daniel Erat | a350fd3 | 2014-09-29 14:02:34 -0700 | [diff] [blame] | 137 | class CheckProjectPrefix(cros_test_lib.MockTempDirTestCase): |
| 138 | """Tests for _check_project_prefix.""" |
| 139 | |
| 140 | def setUp(self): |
| 141 | self.orig_cwd = os.getcwd() |
| 142 | os.chdir(self.tempdir) |
| 143 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 144 | self.desc_mock = self.PatchObject(pre_upload, '_get_commit_desc') |
| 145 | |
| 146 | def tearDown(self): |
| 147 | os.chdir(self.orig_cwd) |
| 148 | |
| 149 | def _WriteAliasFile(self, filename, project): |
| 150 | """Writes a project name to a file, creating directories if needed.""" |
| 151 | os.makedirs(os.path.dirname(filename)) |
| 152 | osutils.WriteFile(filename, project) |
| 153 | |
| 154 | def testInvalidPrefix(self): |
| 155 | """Report an error when the prefix doesn't match the base directory.""" |
| 156 | self.file_mock.return_value = ['foo/foo.cc', 'foo/subdir/baz.cc'] |
| 157 | self.desc_mock.return_value = 'bar: Some commit' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 158 | failure = pre_upload._check_project_prefix(ProjectNamed('PROJECT'), |
| 159 | 'COMMIT') |
Daniel Erat | a350fd3 | 2014-09-29 14:02:34 -0700 | [diff] [blame] | 160 | self.assertTrue(failure) |
| 161 | self.assertEquals(('The commit title for changes affecting only foo' + |
| 162 | ' should start with "foo: "'), failure.msg) |
| 163 | |
| 164 | def testValidPrefix(self): |
| 165 | """Use a prefix that matches the base directory.""" |
| 166 | self.file_mock.return_value = ['foo/foo.cc', 'foo/subdir/baz.cc'] |
| 167 | self.desc_mock.return_value = 'foo: Change some files.' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 168 | self.assertFalse( |
| 169 | pre_upload._check_project_prefix(ProjectNamed('PROJECT'), 'COMMIT')) |
Daniel Erat | a350fd3 | 2014-09-29 14:02:34 -0700 | [diff] [blame] | 170 | |
| 171 | def testAliasFile(self): |
| 172 | """Use .project_alias to override the project name.""" |
| 173 | self._WriteAliasFile('foo/.project_alias', 'project') |
| 174 | self.file_mock.return_value = ['foo/foo.cc', 'foo/subdir/bar.cc'] |
| 175 | self.desc_mock.return_value = 'project: Use an alias.' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 176 | self.assertFalse( |
| 177 | pre_upload._check_project_prefix(ProjectNamed('PROJECT'), 'COMMIT')) |
Daniel Erat | a350fd3 | 2014-09-29 14:02:34 -0700 | [diff] [blame] | 178 | |
| 179 | def testAliasFileWithSubdirs(self): |
| 180 | """Check that .project_alias is used when only modifying subdirectories.""" |
| 181 | self._WriteAliasFile('foo/.project_alias', 'project') |
| 182 | self.file_mock.return_value = [ |
| 183 | 'foo/subdir/foo.cc', |
| 184 | 'foo/subdir/bar.cc' |
| 185 | 'foo/subdir/blah/baz.cc' |
| 186 | ] |
| 187 | self.desc_mock.return_value = 'project: Alias with subdirs.' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 188 | self.assertFalse( |
| 189 | pre_upload._check_project_prefix(ProjectNamed('PROJECT'), 'COMMIT')) |
Daniel Erat | a350fd3 | 2014-09-29 14:02:34 -0700 | [diff] [blame] | 190 | |
| 191 | |
Satoru Takabayashi | 15d17a5 | 2018-08-06 11:12:15 +0900 | [diff] [blame] | 192 | class CheckFilePathCharTypeTest(cros_test_lib.MockTestCase): |
| 193 | """Tests for _check_filepath_chartype.""" |
| 194 | |
| 195 | def setUp(self): |
| 196 | self.diff_mock = self.PatchObject(pre_upload, '_get_file_diff') |
| 197 | |
| 198 | def testCheck(self): |
| 199 | self.PatchObject(pre_upload, '_get_affected_files', return_value=['x.cc']) |
| 200 | self.diff_mock.return_value = [ |
| 201 | (1, 'base::FilePath'), # OK |
| 202 | (2, 'base::FilePath::CharType'), # NG |
| 203 | (3, 'base::FilePath::StringType'), # NG |
| 204 | (4, 'base::FilePath::StringPieceType'), # NG |
Satoru Takabayashi | 4ca3792 | 2018-08-08 10:16:38 +0900 | [diff] [blame^] | 205 | (5, 'base::FilePath::FromUTF8Unsafe'), # NG |
| 206 | (6, 'FilePath::CharType'), # NG |
| 207 | (7, 'FilePath::StringType'), # NG |
| 208 | (8, 'FilePath::StringPieceType'), # NG |
| 209 | (9, 'FilePath::FromUTF8Unsafe'), # NG |
| 210 | (10, 'AsUTF8Unsafe'), # NG |
| 211 | (11, 'FILE_PATH_LITERAL'), # NG |
Satoru Takabayashi | 15d17a5 | 2018-08-06 11:12:15 +0900 | [diff] [blame] | 212 | ] |
| 213 | failure = pre_upload._check_filepath_chartype(ProjectNamed('PROJECT'), |
| 214 | 'COMMIT') |
| 215 | self.assertTrue(failure) |
| 216 | self.assertEquals( |
| 217 | 'Please assume FilePath::CharType is char (crbug.com/870621):', |
| 218 | failure.msg) |
| 219 | self.assertEquals(['x.cc, line 2 has base::FilePath::CharType', |
| 220 | 'x.cc, line 3 has base::FilePath::StringType', |
| 221 | 'x.cc, line 4 has base::FilePath::StringPieceType', |
Satoru Takabayashi | 4ca3792 | 2018-08-08 10:16:38 +0900 | [diff] [blame^] | 222 | 'x.cc, line 5 has base::FilePath::FromUTF8Unsafe', |
| 223 | 'x.cc, line 6 has FilePath::CharType', |
| 224 | 'x.cc, line 7 has FilePath::StringType', |
| 225 | 'x.cc, line 8 has FilePath::StringPieceType', |
| 226 | 'x.cc, line 9 has FilePath::FromUTF8Unsafe', |
| 227 | 'x.cc, line 10 has AsUTF8Unsafe', |
| 228 | 'x.cc, line 11 has FILE_PATH_LITERAL'], |
Satoru Takabayashi | 15d17a5 | 2018-08-06 11:12:15 +0900 | [diff] [blame] | 229 | failure.items) |
| 230 | |
| 231 | |
Mike Frysinger | 1459d36 | 2014-12-06 13:53:23 -0500 | [diff] [blame] | 232 | class CheckKernelConfig(cros_test_lib.MockTestCase): |
Mike Frysinger | ae40952 | 2014-02-01 03:16:11 -0500 | [diff] [blame] | 233 | """Tests for _kernel_configcheck.""" |
| 234 | |
Mike Frysinger | 1459d36 | 2014-12-06 13:53:23 -0500 | [diff] [blame] | 235 | def setUp(self): |
| 236 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 237 | |
| 238 | def testMixedChanges(self): |
| 239 | """Mixing of changes should fail.""" |
| 240 | self.file_mock.return_value = [ |
| 241 | '/kernel/files/chromeos/config/base.config', |
| 242 | '/kernel/files/arch/arm/mach-exynos/mach-exynos5-dt.c' |
| 243 | ] |
Olof Johansson | a96810f | 2012-09-04 16:20:03 -0700 | [diff] [blame] | 244 | failure = pre_upload._kernel_configcheck('PROJECT', 'COMMIT') |
| 245 | self.assertTrue(failure) |
| 246 | |
Mike Frysinger | 1459d36 | 2014-12-06 13:53:23 -0500 | [diff] [blame] | 247 | def testCodeOnly(self): |
| 248 | """Code-only changes should pass.""" |
| 249 | self.file_mock.return_value = [ |
| 250 | '/kernel/files/Makefile', |
| 251 | '/kernel/files/arch/arm/mach-exynos/mach-exynos5-dt.c' |
| 252 | ] |
Olof Johansson | a96810f | 2012-09-04 16:20:03 -0700 | [diff] [blame] | 253 | failure = pre_upload._kernel_configcheck('PROJECT', 'COMMIT') |
| 254 | self.assertFalse(failure) |
| 255 | |
Mike Frysinger | 1459d36 | 2014-12-06 13:53:23 -0500 | [diff] [blame] | 256 | def testConfigOnlyChanges(self): |
| 257 | """Config-only changes should pass.""" |
| 258 | self.file_mock.return_value = [ |
| 259 | '/kernel/files/chromeos/config/base.config', |
| 260 | ] |
Olof Johansson | a96810f | 2012-09-04 16:20:03 -0700 | [diff] [blame] | 261 | failure = pre_upload._kernel_configcheck('PROJECT', 'COMMIT') |
| 262 | self.assertFalse(failure) |
| 263 | |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 264 | |
Mike Frysinger | 908be68 | 2018-01-04 02:21:50 -0500 | [diff] [blame] | 265 | class CheckJson(cros_test_lib.MockTestCase): |
| 266 | """Tests for _run_json_check.""" |
| 267 | |
| 268 | def setUp(self): |
| 269 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 270 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 271 | |
| 272 | def testNoJson(self): |
| 273 | """Nothing should be checked w/no JSON files.""" |
| 274 | self.file_mock.return_value = [ |
| 275 | '/foo/bar.txt', |
| 276 | '/readme.md', |
| 277 | ] |
| 278 | ret = pre_upload._run_json_check('PROJECT', 'COMMIT') |
| 279 | self.assertIsNone(ret) |
| 280 | |
| 281 | def testValidJson(self): |
| 282 | """We should accept valid json files.""" |
| 283 | self.file_mock.return_value = [ |
| 284 | '/foo/bar.txt', |
| 285 | '/data.json', |
| 286 | ] |
| 287 | self.content_mock.return_value = '{}' |
| 288 | ret = pre_upload._run_json_check('PROJECT', 'COMMIT') |
| 289 | self.assertIsNone(ret) |
| 290 | self.content_mock.assert_called_once_with('/data.json', 'COMMIT') |
| 291 | |
| 292 | def testInvalidJson(self): |
| 293 | """We should reject invalid json files.""" |
| 294 | self.file_mock.return_value = [ |
| 295 | '/foo/bar.txt', |
| 296 | '/data.json', |
| 297 | ] |
| 298 | self.content_mock.return_value = '{' |
| 299 | ret = pre_upload._run_json_check('PROJECT', 'COMMIT') |
| 300 | self.assertIsNotNone(ret) |
| 301 | self.content_mock.assert_called_once_with('/data.json', 'COMMIT') |
| 302 | |
| 303 | |
Mike Frysinger | aae3cb5 | 2018-01-03 16:49:33 -0500 | [diff] [blame] | 304 | class CheckManifests(cros_test_lib.MockTestCase): |
| 305 | """Tests _check_manifests.""" |
| 306 | |
| 307 | def setUp(self): |
| 308 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 309 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 310 | |
| 311 | def testNoManifests(self): |
| 312 | """Nothing should be checked w/no Manifest files.""" |
| 313 | self.file_mock.return_value = [ |
| 314 | '/foo/bar.txt', |
| 315 | '/readme.md', |
| 316 | '/manifest', |
| 317 | '/Manifest.txt', |
| 318 | ] |
| 319 | ret = pre_upload._check_manifests('PROJECT', 'COMMIT') |
| 320 | self.assertIsNone(ret) |
| 321 | |
| 322 | def testValidManifest(self): |
| 323 | """Accept valid Manifest files.""" |
| 324 | self.file_mock.return_value = [ |
| 325 | '/foo/bar.txt', |
| 326 | '/cat/pkg/Manifest', |
| 327 | ] |
| 328 | self.content_mock.return_value = '''# Comment and blank lines. |
| 329 | |
| 330 | DIST lines |
| 331 | ''' |
| 332 | ret = pre_upload._check_manifests('PROJECT', 'COMMIT') |
| 333 | self.assertIsNone(ret) |
| 334 | self.content_mock.assert_called_once_with('/cat/pkg/Manifest', 'COMMIT') |
| 335 | |
| 336 | def _testReject(self, content): |
| 337 | """Make sure |content| is rejected.""" |
| 338 | self.file_mock.return_value = ('/Manifest',) |
| 339 | self.content_mock.reset_mock() |
| 340 | self.content_mock.return_value = content |
| 341 | ret = pre_upload._check_manifests('PROJECT', 'COMMIT') |
| 342 | self.assertIsNotNone(ret) |
| 343 | self.content_mock.assert_called_once_with('/Manifest', 'COMMIT') |
| 344 | |
| 345 | def testRejectBlank(self): |
| 346 | """Reject empty manifests.""" |
| 347 | self._testReject('') |
| 348 | |
| 349 | def testNoTrailingNewLine(self): |
| 350 | """Reject manifests w/out trailing newline.""" |
| 351 | self._testReject('DIST foo') |
| 352 | |
| 353 | def testNoLeadingBlankLines(self): |
| 354 | """Reject manifests w/leading blank lines.""" |
| 355 | self._testReject('\nDIST foo\n') |
| 356 | |
| 357 | def testNoTrailingBlankLines(self): |
| 358 | """Reject manifests w/trailing blank lines.""" |
| 359 | self._testReject('DIST foo\n\n') |
| 360 | |
| 361 | def testNoLeadingWhitespace(self): |
| 362 | """Reject manifests w/lines w/leading spaces.""" |
| 363 | self._testReject(' DIST foo\n') |
| 364 | self._testReject(' # Comment\n') |
| 365 | |
| 366 | def testNoTrailingWhitespace(self): |
| 367 | """Reject manifests w/lines w/trailing spaces.""" |
| 368 | self._testReject('DIST foo \n') |
| 369 | self._testReject('# Comment \n') |
| 370 | self._testReject(' \n') |
| 371 | |
| 372 | def testOnlyDistLines(self): |
| 373 | """Only allow DIST lines in here.""" |
| 374 | self._testReject('EBUILD foo\n') |
| 375 | |
| 376 | |
Aviv Keshet | 5ac5952 | 2017-01-31 14:28:27 -0800 | [diff] [blame] | 377 | class CheckConfigParsing(cros_test_lib.MockTestCase): |
| 378 | """Tests _check_cq_ini_well_formed.""" |
| 379 | |
| 380 | def setUp(self): |
| 381 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 382 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 383 | |
| 384 | def testIgnoreIrrelevantFile(self): |
| 385 | self.file_mock.return_value = ['unrelated_file.ini'] |
| 386 | self.content_mock.return_value = '^$malformed gibberish^^&' |
| 387 | self.assertEqual(pre_upload._check_cq_ini_well_formed('PROJECT', 'COMMIT'), |
| 388 | None) |
| 389 | |
| 390 | def testWellformedFile(self): |
| 391 | self.file_mock.return_value = ['COMMIT-QUEUE.ini'] |
| 392 | self.content_mock.return_value = """# |
| 393 | # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| 394 | # Use of this source code is governed by a BSD-style license that can be |
| 395 | # found in the LICENSE file. |
| 396 | |
| 397 | # Per-project Commit Queue settings. |
| 398 | # Documentation: http://goo.gl/4rZhAx |
| 399 | |
| 400 | [GENERAL] |
| 401 | |
| 402 | # Stages to ignore in the commit queue. If these steps break, your CL will be |
| 403 | # submitted anyway. Use with caution. |
| 404 | # The files in here currently only get tested via internal canaries. |
| 405 | ignored-stages: UNitTest HWTest VMTest UploadPrebuilts Archive""" |
| 406 | |
| 407 | self.assertEqual(pre_upload._check_cq_ini_well_formed('PROJECT', 'COMMIT'), |
| 408 | None) |
| 409 | |
| 410 | def testMalformedFile(self): |
| 411 | self.file_mock.return_value = ['COMMIT-QUEUE.ini'] |
| 412 | self.content_mock.return_value = '^$malformed gibberish^^&' |
| 413 | m = pre_upload._check_cq_ini_well_formed('PROJECT', 'COMMIT') |
| 414 | self.assertTrue(isinstance(m, pre_upload.HookFailure)) |
| 415 | |
| 416 | |
Daniel Erat | 9d203ff | 2015-02-17 10:12:21 -0700 | [diff] [blame] | 417 | class CheckPortageMakeUseVar(cros_test_lib.MockTestCase): |
| 418 | """Tests for _check_portage_make_use_var.""" |
| 419 | |
| 420 | def setUp(self): |
| 421 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 422 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 423 | |
| 424 | def testMakeConfOmitsOriginalUseValue(self): |
| 425 | """Fail for make.conf that discards the previous value of $USE.""" |
| 426 | self.file_mock.return_value = ['make.conf'] |
| 427 | self.content_mock.return_value = 'USE="foo"\nUSE="${USE} bar"' |
| 428 | failure = pre_upload._check_portage_make_use_var('PROJECT', 'COMMIT') |
| 429 | self.assertTrue(failure, failure) |
| 430 | |
| 431 | def testMakeConfCorrectUsage(self): |
| 432 | """Succeed for make.conf that preserves the previous value of $USE.""" |
| 433 | self.file_mock.return_value = ['make.conf'] |
| 434 | self.content_mock.return_value = 'USE="${USE} foo"\nUSE="${USE}" bar' |
| 435 | failure = pre_upload._check_portage_make_use_var('PROJECT', 'COMMIT') |
| 436 | self.assertFalse(failure, failure) |
| 437 | |
| 438 | def testMakeDefaultsReferencesOriginalUseValue(self): |
| 439 | """Fail for make.defaults that refers to a not-yet-set $USE value.""" |
| 440 | self.file_mock.return_value = ['make.defaults'] |
| 441 | self.content_mock.return_value = 'USE="${USE} foo"' |
| 442 | failure = pre_upload._check_portage_make_use_var('PROJECT', 'COMMIT') |
| 443 | self.assertTrue(failure, failure) |
| 444 | |
| 445 | # Also check for "$USE" without curly brackets. |
| 446 | self.content_mock.return_value = 'USE="$USE foo"' |
| 447 | failure = pre_upload._check_portage_make_use_var('PROJECT', 'COMMIT') |
| 448 | self.assertTrue(failure, failure) |
| 449 | |
| 450 | def testMakeDefaultsOverwritesUseValue(self): |
| 451 | """Fail for make.defaults that discards its own $USE value.""" |
| 452 | self.file_mock.return_value = ['make.defaults'] |
| 453 | self.content_mock.return_value = 'USE="foo"\nUSE="bar"' |
| 454 | failure = pre_upload._check_portage_make_use_var('PROJECT', 'COMMIT') |
| 455 | self.assertTrue(failure, failure) |
| 456 | |
| 457 | def testMakeDefaultsCorrectUsage(self): |
| 458 | """Succeed for make.defaults that sets and preserves $USE.""" |
| 459 | self.file_mock.return_value = ['make.defaults'] |
| 460 | self.content_mock.return_value = 'USE="foo"\nUSE="${USE}" bar' |
| 461 | failure = pre_upload._check_portage_make_use_var('PROJECT', 'COMMIT') |
| 462 | self.assertFalse(failure, failure) |
| 463 | |
| 464 | |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 465 | class CheckEbuildEapi(cros_test_lib.MockTestCase): |
| 466 | """Tests for _check_ebuild_eapi.""" |
| 467 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 468 | PORTAGE_STABLE = ProjectNamed('chromiumos/overlays/portage-stable') |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 469 | |
| 470 | def setUp(self): |
| 471 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 472 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 473 | self.diff_mock = self.PatchObject(pre_upload, '_get_file_diff', |
| 474 | side_effect=Exception()) |
| 475 | |
| 476 | def testSkipUpstreamOverlays(self): |
| 477 | """Skip ebuilds found in upstream overlays.""" |
| 478 | self.file_mock.side_effect = Exception() |
| 479 | ret = pre_upload._check_ebuild_eapi(self.PORTAGE_STABLE, 'HEAD') |
| 480 | self.assertEqual(ret, None) |
| 481 | |
| 482 | # Make sure our condition above triggers. |
| 483 | self.assertRaises(Exception, pre_upload._check_ebuild_eapi, 'o', 'HEAD') |
| 484 | |
| 485 | def testSkipNonEbuilds(self): |
| 486 | """Skip non-ebuild files.""" |
| 487 | self.content_mock.side_effect = Exception() |
| 488 | |
| 489 | self.file_mock.return_value = ['some-file', 'ebuild/dir', 'an.ebuild~'] |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 490 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 491 | self.assertEqual(ret, None) |
| 492 | |
| 493 | # Make sure our condition above triggers. |
| 494 | self.file_mock.return_value.append('a/real.ebuild') |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 495 | self.assertRaises(Exception, pre_upload._check_ebuild_eapi, |
| 496 | ProjectNamed('o'), 'HEAD') |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 497 | |
| 498 | def testSkipSymlink(self): |
| 499 | """Skip files that are just symlinks.""" |
| 500 | self.file_mock.return_value = ['a-r1.ebuild'] |
| 501 | self.content_mock.return_value = 'a.ebuild' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 502 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 503 | self.assertEqual(ret, None) |
| 504 | |
| 505 | def testRejectEapiImplicit0Content(self): |
| 506 | """Reject ebuilds that do not declare EAPI (so it's 0).""" |
| 507 | self.file_mock.return_value = ['a.ebuild'] |
| 508 | |
| 509 | self.content_mock.return_value = """# Header |
| 510 | IUSE="foo" |
| 511 | src_compile() { } |
| 512 | """ |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 513 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 514 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 515 | |
| 516 | def testRejectExplicitEapi1Content(self): |
| 517 | """Reject ebuilds that do declare old EAPI explicitly.""" |
| 518 | self.file_mock.return_value = ['a.ebuild'] |
| 519 | |
| 520 | template = """# Header |
| 521 | EAPI=%s |
| 522 | IUSE="foo" |
| 523 | src_compile() { } |
| 524 | """ |
| 525 | # Make sure we only check the first EAPI= setting. |
Mike Frysinger | 948284a | 2018-02-01 15:22:56 -0500 | [diff] [blame] | 526 | self.content_mock.return_value = template % '1\nEAPI=60' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 527 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 528 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 529 | |
| 530 | # Verify we handle double quotes too. |
| 531 | self.content_mock.return_value = template % '"1"' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 532 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 533 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 534 | |
| 535 | # Verify we handle single quotes too. |
| 536 | self.content_mock.return_value = template % "'1'" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 537 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 538 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 539 | |
Mike Frysinger | 948284a | 2018-02-01 15:22:56 -0500 | [diff] [blame] | 540 | def testAcceptExplicitNewEapiContent(self): |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 541 | """Accept ebuilds that do declare new EAPI explicitly.""" |
| 542 | self.file_mock.return_value = ['a.ebuild'] |
| 543 | |
| 544 | template = """# Header |
| 545 | EAPI=%s |
| 546 | IUSE="foo" |
| 547 | src_compile() { } |
| 548 | """ |
| 549 | # Make sure we only check the first EAPI= setting. |
Mike Frysinger | 948284a | 2018-02-01 15:22:56 -0500 | [diff] [blame] | 550 | self.content_mock.return_value = template % '6\nEAPI=1' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 551 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 552 | self.assertEqual(ret, None) |
| 553 | |
| 554 | # Verify we handle double quotes too. |
| 555 | self.content_mock.return_value = template % '"5"' |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 556 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 557 | self.assertEqual(ret, None) |
| 558 | |
| 559 | # Verify we handle single quotes too. |
| 560 | self.content_mock.return_value = template % "'5-hdepend'" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 561 | ret = pre_upload._check_ebuild_eapi(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | bf8b91c | 2014-02-01 02:50:27 -0500 | [diff] [blame] | 562 | self.assertEqual(ret, None) |
| 563 | |
| 564 | |
Mike Frysinger | 5c9e58d | 2014-09-09 03:32:50 -0400 | [diff] [blame] | 565 | class CheckEbuildKeywords(cros_test_lib.MockTestCase): |
| 566 | """Tests for _check_ebuild_keywords.""" |
| 567 | |
| 568 | def setUp(self): |
| 569 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 570 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 571 | |
| 572 | def testNoEbuilds(self): |
| 573 | """If no ebuilds are found, do not scan.""" |
| 574 | self.file_mock.return_value = ['a.file', 'ebuild-is-not.foo'] |
| 575 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 576 | ret = pre_upload._check_ebuild_keywords(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | 5c9e58d | 2014-09-09 03:32:50 -0400 | [diff] [blame] | 577 | self.assertEqual(ret, None) |
| 578 | |
| 579 | self.assertEqual(self.content_mock.call_count, 0) |
| 580 | |
| 581 | def testSomeEbuilds(self): |
| 582 | """If ebuilds are found, only scan them.""" |
| 583 | self.file_mock.return_value = ['a.file', 'blah', 'foo.ebuild', 'cow'] |
| 584 | self.content_mock.return_value = '' |
| 585 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 586 | ret = pre_upload._check_ebuild_keywords(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | 5c9e58d | 2014-09-09 03:32:50 -0400 | [diff] [blame] | 587 | self.assertEqual(ret, None) |
| 588 | |
| 589 | self.assertEqual(self.content_mock.call_count, 1) |
| 590 | |
| 591 | def _CheckContent(self, content, fails): |
| 592 | """Test helper for inputs/outputs. |
| 593 | |
| 594 | Args: |
| 595 | content: The ebuild content to test. |
| 596 | fails: Whether |content| should trigger a hook failure. |
| 597 | """ |
| 598 | self.file_mock.return_value = ['a.ebuild'] |
| 599 | self.content_mock.return_value = content |
| 600 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 601 | ret = pre_upload._check_ebuild_keywords(ProjectNamed('overlay'), 'HEAD') |
Mike Frysinger | 5c9e58d | 2014-09-09 03:32:50 -0400 | [diff] [blame] | 602 | if fails: |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 603 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | 5c9e58d | 2014-09-09 03:32:50 -0400 | [diff] [blame] | 604 | else: |
| 605 | self.assertEqual(ret, None) |
| 606 | |
| 607 | self.assertEqual(self.content_mock.call_count, 1) |
| 608 | |
| 609 | def testEmpty(self): |
| 610 | """Check KEYWORDS= is accepted.""" |
| 611 | self._CheckContent('# HEADER\nKEYWORDS=\nblah\n', False) |
| 612 | |
| 613 | def testEmptyQuotes(self): |
| 614 | """Check KEYWORDS="" is accepted.""" |
| 615 | self._CheckContent('# HEADER\nKEYWORDS=" "\nblah\n', False) |
| 616 | |
| 617 | def testStableGlob(self): |
| 618 | """Check KEYWORDS=* is accepted.""" |
| 619 | self._CheckContent('# HEADER\nKEYWORDS="\t*\t"\nblah\n', False) |
| 620 | |
| 621 | def testUnstableGlob(self): |
| 622 | """Check KEYWORDS=~* is accepted.""" |
| 623 | self._CheckContent('# HEADER\nKEYWORDS="~* "\nblah\n', False) |
| 624 | |
| 625 | def testRestrictedGlob(self): |
| 626 | """Check KEYWORDS=-* is accepted.""" |
| 627 | self._CheckContent('# HEADER\nKEYWORDS="\t-* arm"\nblah\n', False) |
| 628 | |
| 629 | def testMissingGlobs(self): |
| 630 | """Reject KEYWORDS missing any globs.""" |
| 631 | self._CheckContent('# HEADER\nKEYWORDS="~arm x86"\nblah\n', True) |
| 632 | |
| 633 | |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 634 | class CheckEbuildVirtualPv(cros_test_lib.MockTestCase): |
| 635 | """Tests for _check_ebuild_virtual_pv.""" |
| 636 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 637 | PORTAGE_STABLE = ProjectNamed('chromiumos/overlays/portage-stable') |
| 638 | CHROMIUMOS_OVERLAY = ProjectNamed('chromiumos/overlays/chromiumos') |
| 639 | BOARD_OVERLAY = ProjectNamed('chromiumos/overlays/board-overlays') |
| 640 | PRIVATE_OVERLAY = ProjectNamed('chromeos/overlays/overlay-link-private') |
| 641 | PRIVATE_VARIANT_OVERLAY = ProjectNamed('chromeos/overlays/' |
| 642 | 'overlay-variant-daisy-spring-private') |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 643 | |
| 644 | def setUp(self): |
| 645 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 646 | |
| 647 | def testNoVirtuals(self): |
| 648 | """Skip non virtual packages.""" |
| 649 | self.file_mock.return_value = ['some/package/package-3.ebuild'] |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 650 | ret = pre_upload._check_ebuild_virtual_pv(ProjectNamed('overlay'), 'H') |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 651 | self.assertEqual(ret, None) |
| 652 | |
| 653 | def testCommonVirtuals(self): |
| 654 | """Non-board overlays should use PV=1.""" |
| 655 | template = 'virtual/foo/foo-%s.ebuild' |
| 656 | self.file_mock.return_value = [template % '1'] |
| 657 | ret = pre_upload._check_ebuild_virtual_pv(self.CHROMIUMOS_OVERLAY, 'H') |
| 658 | self.assertEqual(ret, None) |
| 659 | |
| 660 | self.file_mock.return_value = [template % '2'] |
| 661 | ret = pre_upload._check_ebuild_virtual_pv(self.CHROMIUMOS_OVERLAY, 'H') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 662 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 663 | |
| 664 | def testPublicBoardVirtuals(self): |
| 665 | """Public board overlays should use PV=2.""" |
| 666 | template = 'overlay-lumpy/virtual/foo/foo-%s.ebuild' |
| 667 | self.file_mock.return_value = [template % '2'] |
| 668 | ret = pre_upload._check_ebuild_virtual_pv(self.BOARD_OVERLAY, 'H') |
| 669 | self.assertEqual(ret, None) |
| 670 | |
| 671 | self.file_mock.return_value = [template % '2.5'] |
| 672 | ret = pre_upload._check_ebuild_virtual_pv(self.BOARD_OVERLAY, 'H') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 673 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 674 | |
| 675 | def testPublicBoardVariantVirtuals(self): |
| 676 | """Public board variant overlays should use PV=2.5.""" |
| 677 | template = 'overlay-variant-lumpy-foo/virtual/foo/foo-%s.ebuild' |
| 678 | self.file_mock.return_value = [template % '2.5'] |
| 679 | ret = pre_upload._check_ebuild_virtual_pv(self.BOARD_OVERLAY, 'H') |
| 680 | self.assertEqual(ret, None) |
| 681 | |
| 682 | self.file_mock.return_value = [template % '3'] |
| 683 | ret = pre_upload._check_ebuild_virtual_pv(self.BOARD_OVERLAY, 'H') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 684 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 685 | |
| 686 | def testPrivateBoardVirtuals(self): |
| 687 | """Private board overlays should use PV=3.""" |
| 688 | template = 'virtual/foo/foo-%s.ebuild' |
| 689 | self.file_mock.return_value = [template % '3'] |
| 690 | ret = pre_upload._check_ebuild_virtual_pv(self.PRIVATE_OVERLAY, 'H') |
| 691 | self.assertEqual(ret, None) |
| 692 | |
| 693 | self.file_mock.return_value = [template % '3.5'] |
| 694 | ret = pre_upload._check_ebuild_virtual_pv(self.PRIVATE_OVERLAY, 'H') |
Mike Frysinger | b81102f | 2014-11-21 00:33:35 -0500 | [diff] [blame] | 695 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 696 | |
| 697 | def testPrivateBoardVariantVirtuals(self): |
| 698 | """Private board variant overlays should use PV=3.5.""" |
| 699 | template = 'virtual/foo/foo-%s.ebuild' |
| 700 | self.file_mock.return_value = [template % '3.5'] |
| 701 | ret = pre_upload._check_ebuild_virtual_pv(self.PRIVATE_VARIANT_OVERLAY, 'H') |
| 702 | self.assertEqual(ret, None) |
| 703 | |
Bernie Thompson | e5ee182 | 2016-01-12 14:22:23 -0800 | [diff] [blame] | 704 | def testSpecialVirtuals(self): |
| 705 | """Some cases require deeper versioning and can be >= 4.""" |
| 706 | template = 'virtual/foo/foo-%s.ebuild' |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 707 | self.file_mock.return_value = [template % '4'] |
| 708 | ret = pre_upload._check_ebuild_virtual_pv(self.PRIVATE_VARIANT_OVERLAY, 'H') |
Bernie Thompson | e5ee182 | 2016-01-12 14:22:23 -0800 | [diff] [blame] | 709 | self.assertEqual(ret, None) |
Mike Frysinger | cd363c8 | 2014-02-01 05:20:18 -0500 | [diff] [blame] | 710 | |
Bernie Thompson | e5ee182 | 2016-01-12 14:22:23 -0800 | [diff] [blame] | 711 | self.file_mock.return_value = [template % '4.5'] |
| 712 | ret = pre_upload._check_ebuild_virtual_pv(self.PRIVATE_VARIANT_OVERLAY, 'H') |
| 713 | self.assertEqual(ret, None) |
Mike Frysinger | 9863810 | 2014-08-28 00:15:08 -0400 | [diff] [blame] | 714 | |
Alex Deymo | f5792ce | 2015-08-24 22:50:08 -0700 | [diff] [blame] | 715 | class CheckCrosLicenseCopyrightHeader(cros_test_lib.MockTestCase): |
| 716 | """Tests for _check_cros_license.""" |
Mike Frysinger | 9863810 | 2014-08-28 00:15:08 -0400 | [diff] [blame] | 717 | |
| 718 | def setUp(self): |
| 719 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 720 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 721 | |
| 722 | def testOldHeaders(self): |
| 723 | """Accept old header styles.""" |
| 724 | HEADERS = ( |
| 725 | ('#!/bin/sh\n' |
| 726 | '# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.\n' |
| 727 | '# Use of this source code is governed by a BSD-style license that' |
| 728 | ' can be\n' |
| 729 | '# found in the LICENSE file.\n'), |
| 730 | ('// Copyright 2010-13 The Chromium OS Authors. All rights reserved.\n' |
| 731 | '// Use of this source code is governed by a BSD-style license that' |
| 732 | ' can be\n' |
| 733 | '// found in the LICENSE file.\n'), |
| 734 | ) |
| 735 | self.file_mock.return_value = ['file'] |
| 736 | for header in HEADERS: |
| 737 | self.content_mock.return_value = header |
Alex Deymo | f5792ce | 2015-08-24 22:50:08 -0700 | [diff] [blame] | 738 | self.assertEqual(None, pre_upload._check_cros_license('proj', 'sha1')) |
Mike Frysinger | 9863810 | 2014-08-28 00:15:08 -0400 | [diff] [blame] | 739 | |
| 740 | def testRejectC(self): |
| 741 | """Reject the (c) in newer headers.""" |
| 742 | HEADERS = ( |
| 743 | ('// Copyright (c) 2015 The Chromium OS Authors. All rights reserved.\n' |
| 744 | '// Use of this source code is governed by a BSD-style license that' |
| 745 | ' can be\n' |
| 746 | '// found in the LICENSE file.\n'), |
| 747 | ('// Copyright (c) 2020 The Chromium OS Authors. All rights reserved.\n' |
| 748 | '// Use of this source code is governed by a BSD-style license that' |
| 749 | ' can be\n' |
| 750 | '// found in the LICENSE file.\n'), |
| 751 | ) |
| 752 | self.file_mock.return_value = ['file'] |
| 753 | for header in HEADERS: |
| 754 | self.content_mock.return_value = header |
Alex Deymo | f5792ce | 2015-08-24 22:50:08 -0700 | [diff] [blame] | 755 | self.assertNotEqual(None, pre_upload._check_cros_license('proj', 'sha1')) |
| 756 | |
Ken Turner | d07564b | 2018-02-08 17:57:59 +1100 | [diff] [blame] | 757 | def testIgnoreExcludedPaths(self): |
| 758 | """Ignores excluded paths for license checks.""" |
| 759 | self.file_mock.return_value = ['foo/OWNERS'] |
| 760 | self.content_mock.return_value = ('owner@chromium.org') |
| 761 | self.assertEqual(None, pre_upload._check_cros_license('proj', 'sha1')) |
| 762 | |
Alex Deymo | f5792ce | 2015-08-24 22:50:08 -0700 | [diff] [blame] | 763 | |
| 764 | class CheckAOSPLicenseCopyrightHeader(cros_test_lib.MockTestCase): |
| 765 | """Tests for _check_aosp_license.""" |
| 766 | |
| 767 | def setUp(self): |
| 768 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 769 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 770 | |
| 771 | def testHeaders(self): |
| 772 | """Accept old header styles.""" |
| 773 | HEADERS = ( |
| 774 | """// |
| 775 | // Copyright (C) 2011 The Android Open Source Project |
| 776 | // |
| 777 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 778 | // you may not use this file except in compliance with the License. |
| 779 | // You may obtain a copy of the License at |
| 780 | // |
| 781 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 782 | // |
| 783 | // Unless required by applicable law or agreed to in writing, software |
| 784 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 785 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 786 | // See the License for the specific language governing permissions and |
| 787 | // limitations under the License. |
| 788 | // |
| 789 | """, |
| 790 | """# |
| 791 | # Copyright (c) 2015 The Android Open Source Project |
| 792 | # |
| 793 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 794 | # you may not use this file except in compliance with the License. |
| 795 | # You may obtain a copy of the License at |
| 796 | # |
| 797 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 798 | # |
| 799 | # Unless required by applicable law or agreed to in writing, software |
| 800 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 801 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 802 | # See the License for the specific language governing permissions and |
| 803 | # limitations under the License. |
| 804 | # |
| 805 | """, |
| 806 | ) |
| 807 | self.file_mock.return_value = ['file'] |
| 808 | for header in HEADERS: |
| 809 | self.content_mock.return_value = header |
| 810 | self.assertEqual(None, pre_upload._check_aosp_license('proj', 'sha1')) |
| 811 | |
| 812 | def testRejectNoLinesAround(self): |
| 813 | """Reject headers missing the empty lines before/after the license.""" |
| 814 | HEADERS = ( |
| 815 | """# Copyright (c) 2015 The Android Open Source Project |
| 816 | # |
| 817 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 818 | # you may not use this file except in compliance with the License. |
| 819 | # You may obtain a copy of the License at |
| 820 | # |
| 821 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 822 | # |
| 823 | # Unless required by applicable law or agreed to in writing, software |
| 824 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 825 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 826 | # See the License for the specific language governing permissions and |
| 827 | # limitations under the License. |
| 828 | """, |
| 829 | ) |
| 830 | self.file_mock.return_value = ['file'] |
| 831 | for header in HEADERS: |
| 832 | self.content_mock.return_value = header |
| 833 | self.assertNotEqual(None, pre_upload._check_aosp_license('proj', 'sha1')) |
Mike Frysinger | 9863810 | 2014-08-28 00:15:08 -0400 | [diff] [blame] | 834 | |
Ken Turner | d07564b | 2018-02-08 17:57:59 +1100 | [diff] [blame] | 835 | def testIgnoreExcludedPaths(self): |
| 836 | """Ignores excluded paths for license checks.""" |
| 837 | self.file_mock.return_value = ['foo/OWNERS'] |
| 838 | self.content_mock.return_value = ('owner@chromium.org') |
| 839 | self.assertEqual(None, pre_upload._check_aosp_license('proj', 'sha1')) |
| 840 | |
Mike Frysinger | 9863810 | 2014-08-28 00:15:08 -0400 | [diff] [blame] | 841 | |
Mike Frysinger | d773452 | 2015-02-26 16:12:43 -0500 | [diff] [blame] | 842 | class CheckLayoutConfTestCase(cros_test_lib.MockTestCase): |
| 843 | """Tests for _check_layout_conf.""" |
| 844 | |
| 845 | def setUp(self): |
| 846 | self.file_mock = self.PatchObject(pre_upload, '_get_affected_files') |
| 847 | self.content_mock = self.PatchObject(pre_upload, '_get_file_content') |
| 848 | |
| 849 | def assertAccepted(self, files, project='project', commit='fake sha1'): |
| 850 | """Assert _check_layout_conf accepts |files|.""" |
| 851 | self.file_mock.return_value = files |
| 852 | ret = pre_upload._check_layout_conf(project, commit) |
| 853 | self.assertEqual(ret, None, msg='rejected with:\n%s' % ret) |
| 854 | |
| 855 | def assertRejected(self, files, project='project', commit='fake sha1'): |
| 856 | """Assert _check_layout_conf rejects |files|.""" |
| 857 | self.file_mock.return_value = files |
| 858 | ret = pre_upload._check_layout_conf(project, commit) |
| 859 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
| 860 | |
| 861 | def GetLayoutConf(self, filters=()): |
| 862 | """Return a valid layout.conf with |filters| lines removed.""" |
| 863 | all_lines = [ |
| 864 | 'masters = portage-stable chromiumos', |
| 865 | 'profile-formats = portage-2 profile-default-eapi', |
| 866 | 'profile_eapi_when_unspecified = 5-progress', |
| 867 | 'repo-name = link', |
| 868 | 'thin-manifests = true', |
Mike Frysinger | 5fae62d | 2015-11-11 20:12:15 -0500 | [diff] [blame] | 869 | 'use-manifests = strict', |
Mike Frysinger | d773452 | 2015-02-26 16:12:43 -0500 | [diff] [blame] | 870 | ] |
| 871 | |
| 872 | lines = [] |
| 873 | for line in all_lines: |
| 874 | for filt in filters: |
| 875 | if line.startswith(filt): |
| 876 | break |
| 877 | else: |
| 878 | lines.append(line) |
| 879 | |
| 880 | return '\n'.join(lines) |
| 881 | |
| 882 | def testNoFilesToCheck(self): |
| 883 | """Don't blow up when there are no layout.conf files.""" |
| 884 | self.assertAccepted([]) |
| 885 | |
| 886 | def testRejectRepoNameFile(self): |
| 887 | """If profiles/repo_name is set, kick it out.""" |
| 888 | self.assertRejected(['profiles/repo_name']) |
| 889 | |
| 890 | def testAcceptValidLayoutConf(self): |
| 891 | """Accept a fully valid layout.conf.""" |
| 892 | self.content_mock.return_value = self.GetLayoutConf() |
| 893 | self.assertAccepted(['metadata/layout.conf']) |
| 894 | |
| 895 | def testAcceptUnknownKeys(self): |
| 896 | """Accept keys we don't explicitly know about.""" |
| 897 | self.content_mock.return_value = self.GetLayoutConf() + '\nzzz-top = ok' |
| 898 | self.assertAccepted(['metadata/layout.conf']) |
| 899 | |
| 900 | def testRejectUnsorted(self): |
| 901 | """Reject an unsorted layout.conf.""" |
| 902 | self.content_mock.return_value = 'zzz-top = bad\n' + self.GetLayoutConf() |
| 903 | self.assertRejected(['metadata/layout.conf']) |
| 904 | |
| 905 | def testRejectMissingThinManifests(self): |
| 906 | """Reject a layout.conf missing thin-manifests.""" |
| 907 | self.content_mock.return_value = self.GetLayoutConf( |
| 908 | filters=['thin-manifests']) |
| 909 | self.assertRejected(['metadata/layout.conf']) |
| 910 | |
| 911 | def testRejectMissingUseManifests(self): |
| 912 | """Reject a layout.conf missing use-manifests.""" |
| 913 | self.content_mock.return_value = self.GetLayoutConf( |
| 914 | filters=['use-manifests']) |
| 915 | self.assertRejected(['metadata/layout.conf']) |
| 916 | |
| 917 | def testRejectMissingEapiFallback(self): |
| 918 | """Reject a layout.conf missing profile_eapi_when_unspecified.""" |
| 919 | self.content_mock.return_value = self.GetLayoutConf( |
| 920 | filters=['profile_eapi_when_unspecified']) |
| 921 | self.assertRejected(['metadata/layout.conf']) |
| 922 | |
| 923 | def testRejectMissingRepoName(self): |
| 924 | """Reject a layout.conf missing repo-name.""" |
| 925 | self.content_mock.return_value = self.GetLayoutConf(filters=['repo-name']) |
| 926 | self.assertRejected(['metadata/layout.conf']) |
| 927 | |
| 928 | |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 929 | class CommitMessageTestCase(cros_test_lib.MockTestCase): |
| 930 | """Test case for funcs that check commit messages.""" |
| 931 | |
| 932 | def setUp(self): |
| 933 | self.msg_mock = self.PatchObject(pre_upload, '_get_commit_desc') |
| 934 | |
| 935 | @staticmethod |
| 936 | def CheckMessage(_project, _commit): |
| 937 | raise AssertionError('Test class must declare CheckMessage') |
| 938 | # This dummy return is to silence pylint warning W1111 so we don't have to |
| 939 | # enable it for all the call sites below. |
| 940 | return 1 # pylint: disable=W0101 |
| 941 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 942 | def assertMessageAccepted(self, msg, project=ProjectNamed('project'), |
| 943 | commit='1234'): |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 944 | """Assert _check_change_has_bug_field accepts |msg|.""" |
| 945 | self.msg_mock.return_value = msg |
| 946 | ret = self.CheckMessage(project, commit) |
| 947 | self.assertEqual(ret, None) |
| 948 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 949 | def assertMessageRejected(self, msg, project=ProjectNamed('project'), |
| 950 | commit='1234'): |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 951 | """Assert _check_change_has_bug_field rejects |msg|.""" |
| 952 | self.msg_mock.return_value = msg |
| 953 | ret = self.CheckMessage(project, commit) |
| 954 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
| 955 | |
| 956 | |
| 957 | class CheckCommitMessageBug(CommitMessageTestCase): |
| 958 | """Tests for _check_change_has_bug_field.""" |
| 959 | |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 960 | AOSP_PROJECT = pre_upload.Project(name='overlay', dir='', remote='aosp') |
| 961 | CROS_PROJECT = pre_upload.Project(name='overlay', dir='', remote='cros') |
| 962 | |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 963 | @staticmethod |
| 964 | def CheckMessage(project, commit): |
| 965 | return pre_upload._check_change_has_bug_field(project, commit) |
| 966 | |
| 967 | def testNormal(self): |
| 968 | """Accept a commit message w/a valid BUG.""" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 969 | self.assertMessageAccepted('\nBUG=chromium:1234\n', self.CROS_PROJECT) |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 970 | self.assertMessageAccepted('\nBUG=b:1234\n', self.CROS_PROJECT) |
| 971 | |
| 972 | self.assertMessageAccepted('\nBug: 1234\n', self.AOSP_PROJECT) |
| 973 | self.assertMessageAccepted('\nBug:1234\n', self.AOSP_PROJECT) |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 974 | |
| 975 | def testNone(self): |
| 976 | """Accept BUG=None.""" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 977 | self.assertMessageAccepted('\nBUG=None\n', self.CROS_PROJECT) |
| 978 | self.assertMessageAccepted('\nBUG=none\n', self.CROS_PROJECT) |
| 979 | self.assertMessageAccepted('\nBug: None\n', self.AOSP_PROJECT) |
| 980 | self.assertMessageAccepted('\nBug:none\n', self.AOSP_PROJECT) |
| 981 | |
| 982 | for project in (self.AOSP_PROJECT, self.CROS_PROJECT): |
| 983 | self.assertMessageRejected('\nBUG=NONE\n', project) |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 984 | |
| 985 | def testBlank(self): |
| 986 | """Reject blank values.""" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 987 | for project in (self.AOSP_PROJECT, self.CROS_PROJECT): |
| 988 | self.assertMessageRejected('\nBUG=\n', project) |
| 989 | self.assertMessageRejected('\nBUG= \n', project) |
| 990 | self.assertMessageRejected('\nBug:\n', project) |
| 991 | self.assertMessageRejected('\nBug: \n', project) |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 992 | |
| 993 | def testNotFirstLine(self): |
| 994 | """Reject the first line.""" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 995 | for project in (self.AOSP_PROJECT, self.CROS_PROJECT): |
| 996 | self.assertMessageRejected('BUG=None\n\n\n', project) |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 997 | |
| 998 | def testNotInline(self): |
| 999 | """Reject not at the start of line.""" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 1000 | for project in (self.AOSP_PROJECT, self.CROS_PROJECT): |
| 1001 | self.assertMessageRejected('\n BUG=None\n', project) |
| 1002 | self.assertMessageRejected('\n\tBUG=None\n', project) |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 1003 | |
| 1004 | def testOldTrackers(self): |
| 1005 | """Reject commit messages using old trackers.""" |
Mike Frysinger | a2f2825 | 2017-10-27 22:26:14 -0400 | [diff] [blame] | 1006 | self.assertMessageRejected('\nBUG=chrome-os-partner:1234\n', |
| 1007 | self.CROS_PROJECT) |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 1008 | self.assertMessageRejected('\nBUG=chromium-os:1234\n', self.CROS_PROJECT) |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 1009 | |
| 1010 | def testNoTrackers(self): |
| 1011 | """Reject commit messages w/invalid trackers.""" |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 1012 | self.assertMessageRejected('\nBUG=booga:1234\n', self.CROS_PROJECT) |
| 1013 | self.assertMessageRejected('\nBUG=br:1234\n', self.CROS_PROJECT) |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 1014 | |
| 1015 | def testMissing(self): |
| 1016 | """Reject commit messages w/no BUG line.""" |
| 1017 | self.assertMessageRejected('foo\n') |
| 1018 | |
| 1019 | def testCase(self): |
| 1020 | """Reject bug lines that are not BUG.""" |
| 1021 | self.assertMessageRejected('\nbug=none\n') |
| 1022 | |
| 1023 | |
| 1024 | class CheckCommitMessageCqDepend(CommitMessageTestCase): |
| 1025 | """Tests for _check_change_has_valid_cq_depend.""" |
| 1026 | |
| 1027 | @staticmethod |
| 1028 | def CheckMessage(project, commit): |
| 1029 | return pre_upload._check_change_has_valid_cq_depend(project, commit) |
| 1030 | |
| 1031 | def testNormal(self): |
| 1032 | """Accept valid CQ-DEPENDs line.""" |
| 1033 | self.assertMessageAccepted('\nCQ-DEPEND=CL:1234\n') |
| 1034 | |
| 1035 | def testInvalid(self): |
| 1036 | """Reject invalid CQ-DEPENDs line.""" |
| 1037 | self.assertMessageRejected('\nCQ-DEPEND=CL=1234\n') |
| 1038 | self.assertMessageRejected('\nCQ-DEPEND=None\n') |
| 1039 | |
| 1040 | |
Bernie Thompson | f8fea99 | 2016-01-14 10:27:18 -0800 | [diff] [blame] | 1041 | class CheckCommitMessageContribution(CommitMessageTestCase): |
| 1042 | """Tests for _check_change_is_contribution.""" |
| 1043 | |
| 1044 | @staticmethod |
| 1045 | def CheckMessage(project, commit): |
| 1046 | return pre_upload._check_change_is_contribution(project, commit) |
| 1047 | |
| 1048 | def testNormal(self): |
| 1049 | """Accept a commit message which is a contribution.""" |
| 1050 | self.assertMessageAccepted('\nThis is cool code I am contributing.\n') |
| 1051 | |
| 1052 | def testFailureLowerCase(self): |
| 1053 | """Deny a commit message which is not a contribution.""" |
| 1054 | self.assertMessageRejected('\nThis is not a contribution.\n') |
| 1055 | |
| 1056 | def testFailureUpperCase(self): |
| 1057 | """Deny a commit message which is not a contribution.""" |
| 1058 | self.assertMessageRejected('\nNOT A CONTRIBUTION\n') |
| 1059 | |
| 1060 | |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 1061 | class CheckCommitMessageTest(CommitMessageTestCase): |
| 1062 | """Tests for _check_change_has_test_field.""" |
| 1063 | |
| 1064 | @staticmethod |
| 1065 | def CheckMessage(project, commit): |
| 1066 | return pre_upload._check_change_has_test_field(project, commit) |
| 1067 | |
| 1068 | def testNormal(self): |
| 1069 | """Accept a commit message w/a valid TEST.""" |
| 1070 | self.assertMessageAccepted('\nTEST=i did it\n') |
| 1071 | |
| 1072 | def testNone(self): |
| 1073 | """Accept TEST=None.""" |
| 1074 | self.assertMessageAccepted('\nTEST=None\n') |
| 1075 | self.assertMessageAccepted('\nTEST=none\n') |
| 1076 | |
| 1077 | def testBlank(self): |
| 1078 | """Reject blank values.""" |
| 1079 | self.assertMessageRejected('\nTEST=\n') |
| 1080 | self.assertMessageRejected('\nTEST= \n') |
| 1081 | |
| 1082 | def testNotFirstLine(self): |
| 1083 | """Reject the first line.""" |
| 1084 | self.assertMessageRejected('TEST=None\n\n\n') |
| 1085 | |
| 1086 | def testNotInline(self): |
| 1087 | """Reject not at the start of line.""" |
| 1088 | self.assertMessageRejected('\n TEST=None\n') |
| 1089 | self.assertMessageRejected('\n\tTEST=None\n') |
| 1090 | |
| 1091 | def testMissing(self): |
| 1092 | """Reject commit messages w/no TEST line.""" |
| 1093 | self.assertMessageRejected('foo\n') |
| 1094 | |
| 1095 | def testCase(self): |
| 1096 | """Reject bug lines that are not TEST.""" |
| 1097 | self.assertMessageRejected('\ntest=none\n') |
| 1098 | |
| 1099 | |
| 1100 | class CheckCommitMessageChangeId(CommitMessageTestCase): |
| 1101 | """Tests for _check_change_has_proper_changeid.""" |
| 1102 | |
| 1103 | @staticmethod |
| 1104 | def CheckMessage(project, commit): |
| 1105 | return pre_upload._check_change_has_proper_changeid(project, commit) |
| 1106 | |
| 1107 | def testNormal(self): |
| 1108 | """Accept a commit message w/a valid Change-Id.""" |
| 1109 | self.assertMessageAccepted('foo\n\nChange-Id: I1234\n') |
| 1110 | |
| 1111 | def testBlank(self): |
| 1112 | """Reject blank values.""" |
| 1113 | self.assertMessageRejected('\nChange-Id:\n') |
| 1114 | self.assertMessageRejected('\nChange-Id: \n') |
| 1115 | |
| 1116 | def testNotFirstLine(self): |
| 1117 | """Reject the first line.""" |
| 1118 | self.assertMessageRejected('TEST=None\n\n\n') |
| 1119 | |
| 1120 | def testNotInline(self): |
| 1121 | """Reject not at the start of line.""" |
| 1122 | self.assertMessageRejected('\n Change-Id: I1234\n') |
| 1123 | self.assertMessageRejected('\n\tChange-Id: I1234\n') |
| 1124 | |
| 1125 | def testMissing(self): |
| 1126 | """Reject commit messages missing the line.""" |
| 1127 | self.assertMessageRejected('foo\n') |
| 1128 | |
| 1129 | def testCase(self): |
| 1130 | """Reject bug lines that are not Change-Id.""" |
| 1131 | self.assertMessageRejected('\nchange-id: I1234\n') |
| 1132 | self.assertMessageRejected('\nChange-id: I1234\n') |
| 1133 | self.assertMessageRejected('\nChange-ID: I1234\n') |
| 1134 | |
| 1135 | def testEnd(self): |
| 1136 | """Reject Change-Id's that are not last.""" |
| 1137 | self.assertMessageRejected('\nChange-Id: I1234\nbar\n') |
| 1138 | |
Mike Frysinger | 02b88bd | 2014-11-21 00:29:38 -0500 | [diff] [blame] | 1139 | def testSobTag(self): |
| 1140 | """Permit s-o-b tags to follow the Change-Id.""" |
| 1141 | self.assertMessageAccepted('foo\n\nChange-Id: I1234\nSigned-off-by: Hi\n') |
| 1142 | |
Mike Frysinger | 4a22bf0 | 2014-10-31 13:53:35 -0400 | [diff] [blame] | 1143 | |
Mike Frysinger | 36b2ebc | 2014-10-31 14:02:03 -0400 | [diff] [blame] | 1144 | class CheckCommitMessageStyle(CommitMessageTestCase): |
| 1145 | """Tests for _check_commit_message_style.""" |
| 1146 | |
| 1147 | @staticmethod |
| 1148 | def CheckMessage(project, commit): |
| 1149 | return pre_upload._check_commit_message_style(project, commit) |
| 1150 | |
| 1151 | def testNormal(self): |
| 1152 | """Accept valid commit messages.""" |
| 1153 | self.assertMessageAccepted('one sentence.\n') |
| 1154 | self.assertMessageAccepted('some.module: do it!\n') |
| 1155 | self.assertMessageAccepted('one line\n\nmore stuff here.') |
| 1156 | |
| 1157 | def testNoBlankSecondLine(self): |
| 1158 | """Reject messages that have stuff on the second line.""" |
| 1159 | self.assertMessageRejected('one sentence.\nbad fish!\n') |
| 1160 | |
| 1161 | def testFirstLineMultipleSentences(self): |
| 1162 | """Reject messages that have more than one sentence in the summary.""" |
| 1163 | self.assertMessageRejected('one sentence. two sentence!\n') |
| 1164 | |
| 1165 | def testFirstLineTooLone(self): |
| 1166 | """Reject first lines that are too long.""" |
| 1167 | self.assertMessageRejected('o' * 200) |
| 1168 | |
| 1169 | |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1170 | def DiffEntry(src_file=None, dst_file=None, src_mode=None, dst_mode='100644', |
| 1171 | status='M'): |
| 1172 | """Helper to create a stub RawDiffEntry object""" |
| 1173 | if src_mode is None: |
| 1174 | if status == 'A': |
| 1175 | src_mode = '000000' |
| 1176 | elif status == 'M': |
| 1177 | src_mode = dst_mode |
| 1178 | elif status == 'D': |
| 1179 | src_mode = dst_mode |
| 1180 | dst_mode = '000000' |
| 1181 | |
| 1182 | src_sha = dst_sha = 'abc' |
| 1183 | if status == 'D': |
| 1184 | dst_sha = '000000' |
| 1185 | elif status == 'A': |
| 1186 | src_sha = '000000' |
| 1187 | |
| 1188 | return git.RawDiffEntry(src_mode=src_mode, dst_mode=dst_mode, src_sha=src_sha, |
| 1189 | dst_sha=dst_sha, status=status, score=None, |
| 1190 | src_file=src_file, dst_file=dst_file) |
| 1191 | |
| 1192 | |
Daniel Erat | e3ea3fc | 2015-02-13 15:27:52 -0700 | [diff] [blame] | 1193 | class HelpersTest(cros_test_lib.MockTempDirTestCase): |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1194 | """Various tests for utility functions.""" |
| 1195 | |
Daniel Erat | e3ea3fc | 2015-02-13 15:27:52 -0700 | [diff] [blame] | 1196 | def setUp(self): |
| 1197 | self.orig_cwd = os.getcwd() |
| 1198 | os.chdir(self.tempdir) |
| 1199 | |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1200 | self.PatchObject(git, 'RawDiff', return_value=[ |
| 1201 | # A modified normal file. |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1202 | DiffEntry(src_file='buildbot/constants.py', status='M'), |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1203 | # A new symlink file. |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1204 | DiffEntry(dst_file='scripts/cros_env_whitelist', dst_mode='120000', |
| 1205 | status='A'), |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1206 | # A deleted file. |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1207 | DiffEntry(src_file='scripts/sync_sonic.py', status='D'), |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1208 | ]) |
| 1209 | |
Daniel Erat | e3ea3fc | 2015-02-13 15:27:52 -0700 | [diff] [blame] | 1210 | def tearDown(self): |
| 1211 | os.chdir(self.orig_cwd) |
| 1212 | |
| 1213 | def _WritePresubmitIgnoreFile(self, subdir, data): |
| 1214 | """Writes to a .presubmitignore file in the passed-in subdirectory.""" |
| 1215 | directory = os.path.join(self.tempdir, subdir) |
| 1216 | if not os.path.exists(directory): |
| 1217 | os.makedirs(directory) |
| 1218 | osutils.WriteFile(os.path.join(directory, pre_upload._IGNORE_FILE), data) |
| 1219 | |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1220 | def testGetAffectedFilesNoDeletesNoRelative(self): |
| 1221 | """Verify _get_affected_files() works w/no delete & not relative.""" |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1222 | path = os.getcwd() |
| 1223 | files = pre_upload._get_affected_files('HEAD', include_deletes=False, |
| 1224 | relative=False) |
| 1225 | exp_files = [os.path.join(path, 'buildbot/constants.py')] |
| 1226 | self.assertEquals(files, exp_files) |
| 1227 | |
| 1228 | def testGetAffectedFilesDeletesNoRelative(self): |
| 1229 | """Verify _get_affected_files() works w/delete & not relative.""" |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1230 | path = os.getcwd() |
| 1231 | files = pre_upload._get_affected_files('HEAD', include_deletes=True, |
| 1232 | relative=False) |
| 1233 | exp_files = [os.path.join(path, 'buildbot/constants.py'), |
| 1234 | os.path.join(path, 'scripts/sync_sonic.py')] |
| 1235 | self.assertEquals(files, exp_files) |
| 1236 | |
| 1237 | def testGetAffectedFilesNoDeletesRelative(self): |
| 1238 | """Verify _get_affected_files() works w/no delete & relative.""" |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1239 | files = pre_upload._get_affected_files('HEAD', include_deletes=False, |
| 1240 | relative=True) |
| 1241 | exp_files = ['buildbot/constants.py'] |
| 1242 | self.assertEquals(files, exp_files) |
| 1243 | |
| 1244 | def testGetAffectedFilesDeletesRelative(self): |
| 1245 | """Verify _get_affected_files() works w/delete & relative.""" |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1246 | files = pre_upload._get_affected_files('HEAD', include_deletes=True, |
| 1247 | relative=True) |
| 1248 | exp_files = ['buildbot/constants.py', 'scripts/sync_sonic.py'] |
| 1249 | self.assertEquals(files, exp_files) |
| 1250 | |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1251 | def testGetAffectedFilesDetails(self): |
| 1252 | """Verify _get_affected_files() works w/full_details.""" |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1253 | files = pre_upload._get_affected_files('HEAD', full_details=True, |
| 1254 | relative=True) |
| 1255 | self.assertEquals(files[0].src_file, 'buildbot/constants.py') |
| 1256 | |
Daniel Erat | e3ea3fc | 2015-02-13 15:27:52 -0700 | [diff] [blame] | 1257 | def testGetAffectedFilesPresubmitIgnoreDirectory(self): |
| 1258 | """Verify .presubmitignore can be used to exclude a directory.""" |
| 1259 | self._WritePresubmitIgnoreFile('.', 'buildbot/') |
| 1260 | self.assertEquals(pre_upload._get_affected_files('HEAD', relative=True), []) |
| 1261 | |
| 1262 | def testGetAffectedFilesPresubmitIgnoreDirectoryWildcard(self): |
| 1263 | """Verify .presubmitignore can be used with a directory wildcard.""" |
| 1264 | self._WritePresubmitIgnoreFile('.', '*/constants.py') |
| 1265 | self.assertEquals(pre_upload._get_affected_files('HEAD', relative=True), []) |
| 1266 | |
| 1267 | def testGetAffectedFilesPresubmitIgnoreWithinDirectory(self): |
| 1268 | """Verify .presubmitignore can be placed in a subdirectory.""" |
| 1269 | self._WritePresubmitIgnoreFile('buildbot', '*.py') |
| 1270 | self.assertEquals(pre_upload._get_affected_files('HEAD', relative=True), []) |
| 1271 | |
| 1272 | def testGetAffectedFilesPresubmitIgnoreDoesntMatch(self): |
| 1273 | """Verify .presubmitignore has no effect when it doesn't match a file.""" |
| 1274 | self._WritePresubmitIgnoreFile('buildbot', '*.txt') |
| 1275 | self.assertEquals(pre_upload._get_affected_files('HEAD', relative=True), |
| 1276 | ['buildbot/constants.py']) |
| 1277 | |
| 1278 | def testGetAffectedFilesPresubmitIgnoreAddedFile(self): |
| 1279 | """Verify .presubmitignore matches added files.""" |
| 1280 | self._WritePresubmitIgnoreFile('.', 'buildbot/\nscripts/') |
| 1281 | self.assertEquals(pre_upload._get_affected_files('HEAD', relative=True, |
| 1282 | include_symlinks=True), |
| 1283 | []) |
| 1284 | |
| 1285 | def testGetAffectedFilesPresubmitIgnoreSkipIgnoreFile(self): |
| 1286 | """Verify .presubmitignore files are automatically skipped.""" |
| 1287 | self.PatchObject(git, 'RawDiff', return_value=[ |
| 1288 | DiffEntry(src_file='.presubmitignore', status='M') |
| 1289 | ]) |
| 1290 | self.assertEquals(pre_upload._get_affected_files('HEAD', relative=True), []) |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1291 | |
Mike Frysinger | f9d41b3 | 2017-02-23 15:20:04 -0500 | [diff] [blame] | 1292 | |
| 1293 | class ExecFilesTest(cros_test_lib.MockTestCase): |
| 1294 | """Tests for _check_exec_files.""" |
| 1295 | |
| 1296 | def setUp(self): |
| 1297 | self.diff_mock = self.PatchObject(git, 'RawDiff') |
| 1298 | |
| 1299 | def testNotExec(self): |
| 1300 | """Do not flag files that are not executable.""" |
| 1301 | self.diff_mock.return_value = [ |
| 1302 | DiffEntry(src_file='make.conf', dst_mode='100644', status='A'), |
| 1303 | ] |
| 1304 | self.assertEqual(pre_upload._check_exec_files('proj', 'commit'), None) |
| 1305 | |
| 1306 | def testExec(self): |
| 1307 | """Flag files that are executable.""" |
| 1308 | self.diff_mock.return_value = [ |
| 1309 | DiffEntry(src_file='make.conf', dst_mode='100755', status='A'), |
| 1310 | ] |
| 1311 | self.assertNotEqual(pre_upload._check_exec_files('proj', 'commit'), None) |
| 1312 | |
| 1313 | def testDeletedExec(self): |
| 1314 | """Ignore bad files that are being deleted.""" |
| 1315 | self.diff_mock.return_value = [ |
| 1316 | DiffEntry(src_file='make.conf', dst_mode='100755', status='D'), |
| 1317 | ] |
| 1318 | self.assertEqual(pre_upload._check_exec_files('proj', 'commit'), None) |
| 1319 | |
| 1320 | def testModifiedExec(self): |
| 1321 | """Flag bad files that weren't exec, but now are.""" |
| 1322 | self.diff_mock.return_value = [ |
| 1323 | DiffEntry(src_file='make.conf', src_mode='100644', dst_mode='100755', |
| 1324 | status='M'), |
| 1325 | ] |
| 1326 | self.assertNotEqual(pre_upload._check_exec_files('proj', 'commit'), None) |
| 1327 | |
| 1328 | def testNormalExec(self): |
| 1329 | """Don't flag normal files (e.g. scripts) that are executable.""" |
| 1330 | self.diff_mock.return_value = [ |
| 1331 | DiffEntry(src_file='foo.sh', dst_mode='100755', status='A'), |
| 1332 | ] |
| 1333 | self.assertEqual(pre_upload._check_exec_files('proj', 'commit'), None) |
| 1334 | |
| 1335 | |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1336 | class CheckForUprev(cros_test_lib.MockTempDirTestCase): |
| 1337 | """Tests for _check_for_uprev.""" |
| 1338 | |
| 1339 | def setUp(self): |
| 1340 | self.file_mock = self.PatchObject(git, 'RawDiff') |
| 1341 | |
| 1342 | def _Files(self, files): |
| 1343 | """Create |files| in the tempdir and return full paths to them.""" |
| 1344 | for obj in files: |
| 1345 | if obj.status == 'D': |
| 1346 | continue |
| 1347 | if obj.dst_file is None: |
| 1348 | f = obj.src_file |
| 1349 | else: |
| 1350 | f = obj.dst_file |
| 1351 | osutils.Touch(os.path.join(self.tempdir, f), makedirs=True) |
| 1352 | return files |
| 1353 | |
| 1354 | def assertAccepted(self, files, project='project', commit='fake sha1'): |
| 1355 | """Assert _check_for_uprev accepts |files|.""" |
| 1356 | self.file_mock.return_value = self._Files(files) |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 1357 | ret = pre_upload._check_for_uprev(ProjectNamed(project), commit, |
| 1358 | project_top=self.tempdir) |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1359 | self.assertEqual(ret, None) |
| 1360 | |
| 1361 | def assertRejected(self, files, project='project', commit='fake sha1'): |
| 1362 | """Assert _check_for_uprev rejects |files|.""" |
| 1363 | self.file_mock.return_value = self._Files(files) |
Alex Deymo | 643ac4c | 2015-09-03 10:40:50 -0700 | [diff] [blame] | 1364 | ret = pre_upload._check_for_uprev(ProjectNamed(project), commit, |
| 1365 | project_top=self.tempdir) |
Mike Frysinger | 292b45d | 2014-11-25 01:17:10 -0500 | [diff] [blame] | 1366 | self.assertTrue(isinstance(ret, errors.HookFailure)) |
| 1367 | |
| 1368 | def testWhitelistOverlay(self): |
| 1369 | """Skip checks on whitelisted overlays.""" |
| 1370 | self.assertAccepted([DiffEntry(src_file='cat/pkg/pkg-0.ebuild')], |
| 1371 | project='chromiumos/overlays/portage-stable') |
| 1372 | |
| 1373 | def testWhitelistFiles(self): |
| 1374 | """Skip checks on whitelisted files.""" |
| 1375 | files = ['ChangeLog', 'Manifest', 'metadata.xml'] |
| 1376 | self.assertAccepted([DiffEntry(src_file=os.path.join('c', 'p', x), |
| 1377 | status='M') |
| 1378 | for x in files]) |
| 1379 | |
| 1380 | def testRejectBasic(self): |
| 1381 | """Reject ebuilds missing uprevs.""" |
| 1382 | self.assertRejected([DiffEntry(src_file='c/p/p-0.ebuild', status='M')]) |
| 1383 | |
| 1384 | def testNewPackage(self): |
| 1385 | """Accept new ebuilds w/out uprevs.""" |
| 1386 | self.assertAccepted([DiffEntry(src_file='c/p/p-0.ebuild', status='A')]) |
| 1387 | self.assertAccepted([DiffEntry(src_file='c/p/p-0-r12.ebuild', status='A')]) |
| 1388 | |
| 1389 | def testModifiedFilesOnly(self): |
| 1390 | """Reject ebuilds w/out uprevs and changes in files/.""" |
| 1391 | osutils.Touch(os.path.join(self.tempdir, 'cat/pkg/pkg-0.ebuild'), |
| 1392 | makedirs=True) |
| 1393 | self.assertRejected([DiffEntry(src_file='cat/pkg/files/f', status='A')]) |
| 1394 | self.assertRejected([DiffEntry(src_file='cat/pkg/files/g', status='M')]) |
| 1395 | |
| 1396 | def testFilesNoEbuilds(self): |
| 1397 | """Ignore changes to paths w/out ebuilds.""" |
| 1398 | self.assertAccepted([DiffEntry(src_file='cat/pkg/files/f', status='A')]) |
| 1399 | self.assertAccepted([DiffEntry(src_file='cat/pkg/files/g', status='M')]) |
| 1400 | |
| 1401 | def testModifiedFilesWithUprev(self): |
| 1402 | """Accept ebuilds w/uprevs and changes in files/.""" |
| 1403 | self.assertAccepted([DiffEntry(src_file='c/p/files/f', status='A'), |
| 1404 | DiffEntry(src_file='c/p/p-0.ebuild', status='A')]) |
| 1405 | self.assertAccepted([ |
| 1406 | DiffEntry(src_file='c/p/files/f', status='M'), |
| 1407 | DiffEntry(src_file='c/p/p-0-r1.ebuild', src_mode='120000', |
| 1408 | dst_file='c/p/p-0-r2.ebuild', dst_mode='120000', status='R')]) |
| 1409 | |
Gwendal Grignou | a3086c3 | 2014-12-09 11:17:22 -0800 | [diff] [blame] | 1410 | def testModifiedFilesWith9999(self): |
| 1411 | """Accept 9999 ebuilds and changes in files/.""" |
| 1412 | self.assertAccepted([DiffEntry(src_file='c/p/files/f', status='M'), |
| 1413 | DiffEntry(src_file='c/p/p-9999.ebuild', status='M')]) |
| 1414 | |
C Shapiro | ae157ae | 2017-09-18 16:24:03 -0600 | [diff] [blame] | 1415 | def testModifiedFilesIn9999SubDirWithout9999Change(self): |
| 1416 | """Accept changes in files/ with a parent 9999 ebuild""" |
| 1417 | ebuild_9999_file = os.path.join(self.tempdir, 'c/p/p-9999.ebuild') |
| 1418 | os.makedirs(os.path.dirname(ebuild_9999_file)) |
| 1419 | osutils.WriteFile(ebuild_9999_file, 'fake') |
| 1420 | self.assertAccepted([DiffEntry(src_file='c/p/files/f', status='M')]) |
| 1421 | |
Mike Frysinger | d3bd32c | 2014-11-24 23:34:29 -0500 | [diff] [blame] | 1422 | |
Mike Frysinger | 55f85b5 | 2014-12-18 14:45:21 -0500 | [diff] [blame] | 1423 | class DirectMainTest(cros_test_lib.MockTempDirTestCase): |
| 1424 | """Tests for direct_main()""" |
| 1425 | |
| 1426 | def setUp(self): |
| 1427 | self.hooks_mock = self.PatchObject(pre_upload, '_run_project_hooks', |
| 1428 | return_value=None) |
| 1429 | |
| 1430 | def testNoArgs(self): |
| 1431 | """If run w/no args, should check the current dir.""" |
| 1432 | ret = pre_upload.direct_main([]) |
| 1433 | self.assertEqual(ret, 0) |
| 1434 | self.hooks_mock.assert_called_once_with( |
| 1435 | mock.ANY, proj_dir=os.getcwd(), commit_list=[], presubmit=mock.ANY) |
| 1436 | |
| 1437 | def testExplicitDir(self): |
| 1438 | """Verify we can run on a diff dir.""" |
| 1439 | # Use the chromite dir since we know it exists. |
| 1440 | ret = pre_upload.direct_main(['--dir', constants.CHROMITE_DIR]) |
| 1441 | self.assertEqual(ret, 0) |
| 1442 | self.hooks_mock.assert_called_once_with( |
| 1443 | mock.ANY, proj_dir=constants.CHROMITE_DIR, commit_list=[], |
| 1444 | presubmit=mock.ANY) |
| 1445 | |
| 1446 | def testBogusProject(self): |
| 1447 | """A bogus project name should be fine (use default settings).""" |
| 1448 | # Use the chromite dir since we know it exists. |
| 1449 | ret = pre_upload.direct_main(['--dir', constants.CHROMITE_DIR, |
| 1450 | '--project', 'foooooooooo']) |
| 1451 | self.assertEqual(ret, 0) |
| 1452 | self.hooks_mock.assert_called_once_with( |
| 1453 | 'foooooooooo', proj_dir=constants.CHROMITE_DIR, commit_list=[], |
| 1454 | presubmit=mock.ANY) |
| 1455 | |
| 1456 | def testBogustProjectNoDir(self): |
| 1457 | """Make sure --dir is detected even with --project.""" |
| 1458 | ret = pre_upload.direct_main(['--project', 'foooooooooo']) |
| 1459 | self.assertEqual(ret, 0) |
| 1460 | self.hooks_mock.assert_called_once_with( |
| 1461 | 'foooooooooo', proj_dir=os.getcwd(), commit_list=[], |
| 1462 | presubmit=mock.ANY) |
| 1463 | |
| 1464 | def testNoGitDir(self): |
| 1465 | """We should die when run on a non-git dir.""" |
| 1466 | self.assertRaises(pre_upload.BadInvocation, pre_upload.direct_main, |
| 1467 | ['--dir', self.tempdir]) |
| 1468 | |
| 1469 | def testNoDir(self): |
| 1470 | """We should die when run on a missing dir.""" |
| 1471 | self.assertRaises(pre_upload.BadInvocation, pre_upload.direct_main, |
| 1472 | ['--dir', os.path.join(self.tempdir, 'foooooooo')]) |
| 1473 | |
| 1474 | def testCommitList(self): |
| 1475 | """Any args on the command line should be treated as commits.""" |
| 1476 | commits = ['sha1', 'sha2', 'shaaaaaaaaaaaan'] |
| 1477 | ret = pre_upload.direct_main(commits) |
| 1478 | self.assertEqual(ret, 0) |
| 1479 | self.hooks_mock.assert_called_once_with( |
| 1480 | mock.ANY, proj_dir=mock.ANY, commit_list=commits, presubmit=mock.ANY) |
| 1481 | |
| 1482 | |
Jon Salz | 9825593 | 2012-08-18 14:48:02 +0800 | [diff] [blame] | 1483 | if __name__ == '__main__': |
Mike Frysinger | 884a8dd | 2015-05-17 03:43:43 -0400 | [diff] [blame] | 1484 | cros_test_lib.main(module=__name__) |