def testTypicalConflict(self):

lines = [

'<<<<<<< HEAD', ' base::ScopedTempDir temp_dir_;', '=======',

' ScopedTempDir temp_dir_;', '>>>>>>> master'

]

errors = PRESUBMIT._CheckForVersionControlConflictsInFile(

MockInputApi(), MockFile('some/path/foo_platform.cc', lines))

self.assertEqual(3, len(errors))

self.assertIn('1', errors[0])

self.assertIn('3', errors[1])

self.assertIn('5', errors[2])

def testIgnoresReadmes(self):

lines = [

'A First Level Header', '====================', '',

'A Second Level Header', '---------------------'

]

errors = PRESUBMIT._CheckForVersionControlConflictsInFile(

MockInputApi(), MockFile('some/polymer/README.md', lines))

self.assertEqual(0, len(errors))

def testIgnoresVendoredCrates(self):

lines = [

'<<<<<<< HEAD', 'pub fn foo() {}', '=======', 'pub fn bar() {}',

'>>>>>>> main'

]

vendored_paths = [

'third_party/rust/chromium_crates_io/vendor/serde-1.0/src/lib.rs',

'third_party\\rust\\chromium_crates_io\\vendor\\syn\\src\\lib.rs',

]

mock_input_api = MockInputApi()

mock_input_api.files = [MockFile(p, lines) for p in vendored_paths]

results = PRESUBMIT.CheckForVersionControlConflicts(

mock_input_api, MockOutputApi())

self.assertEqual(0, len(results))

def testChecksFirstPartyAndMixedChanges(self):

lines = [

'<<<<<<< HEAD', 'conflict line', '=======', 'resolved line',

'>>>>>>> main'

]

mixed_files = [

MockFile('chrome/browser/ui/foo.cc', lines),

MockFile(

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs',

lines),

# Edge case: a crate named "vendor" must not be bypassed.

MockFile('third_party/rust/vendor/v1/BUILD.gn', lines),

MockFile('third_party/rust/chromium_crates_io/Cargo.toml', lines),

]

mock_input_api = MockInputApi()

mock_input_api.files = mixed_files

results = PRESUBMIT.CheckForVersionControlConflicts(

mock_input_api, MockOutputApi())

self.assertEqual(1, len(results))

# 3 conflict markers in each of the 3 first-party files = 9 errors.

self.assertEqual(9, len(results[0].items))

reported_paths = ' '.join(results[0].items)

self.assertIn('chrome/browser/ui/foo.cc', reported_paths)

self.assertIn('third_party/rust/vendor/v1/BUILD.gn', reported_paths)

self.assertIn('third_party/rust/chromium_crates_io/Cargo.toml',

reported_paths)

def testVendoredCratesPathMatching(self):

self.assertTrue(

PRESUBMIT._IsVendoredCratesFile(

MockFile('third_party/rust/chromium_crates_io/vendor/foo.rs',

[])))

self.assertTrue(

PRESUBMIT._IsVendoredCratesFile(

MockFile('third_party/rust/chromium_crates_io/vendor', [])))

self.assertTrue(

PRESUBMIT._IsVendoredCratesFile(

MockFile(

'third_party\\rust\\chromium_crates_io\\vendor\\foo.rs',

[])))

self.assertTrue(

PRESUBMIT._IsVendoredCratesFile(

MockFile('third_party/rust/other_store/vendor/bar.rs', [])))

# Crate named "vendor" is first-party code and must not match.

self.assertFalse(

PRESUBMIT._IsVendoredCratesFile(

MockFile('third_party/rust/vendor/v1/BUILD.gn', [])))

self.assertFalse(

PRESUBMIT._IsVendoredCratesFile(

MockFile('third_party/rust/chromium_crates_io/Cargo.toml',

[])))

self.assertFalse(

PRESUBMIT._IsVendoredCratesFile(

MockFile('chrome/browser/ui/foo.cc', [])))

def testCheckPatchFormattedBypassesVendoredCrates(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile('chrome/browser/ui/foo.cc', ['int x = 1;']),

MockFile(

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs',

['pub fn foo() {}']),

]

mock_input_api.canned_checks.CheckPatchFormatted = mock.Mock(

return_value=[])

PRESUBMIT.CheckPatchFormatted(mock_input_api, MockOutputApi())

mock_input_api.canned_checks.CheckPatchFormatted.assert_called_once()

call_args, call_kwargs = (

mock_input_api.canned_checks.CheckPatchFormatted.call_args)

self.assertIs(call_args[0], mock_input_api)

file_filter = call_kwargs.get('file_filter')

self.assertIsNotNone(file_filter)

self.assertTrue(file_filter(MockFile('chrome/browser/ui/foo.cc', [])))

serde_path = (

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs')

self.assertFalse(file_filter(MockFile(serde_path, [])))

def testFunctionalCheckInclusiveLanguageBypass(self):

try:

import presubmit_canned_checks

except ImportError:

raise unittest.SkipTest('presubmit_canned_checks not available')

mock_input_api = MockInputApi()

mock_input_api.ReadFile = mock.Mock(return_value='')

mock_input_api.files = [

MockFile(

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs',

['let branch = "master";']), # nocheck

]

results = (presubmit_canned_checks.CheckInclusiveLanguage(

mock_input_api,

MockOutputApi(),

excluded_directories_relative_path=['exempt.txt'],

non_inclusive_terms=PRESUBMIT._NON_INCLUSIVE_TERMS,

source_file_filter=lambda f: not PRESUBMIT._IsVendoredCratesFile(

f)))

self.assertEqual(0, len(results))

mock_input_api.files = [

MockFile('chrome/browser/ui/foo.cc',

['const char* kBranch = "master";']), # nocheck

]

results_fp = (presubmit_canned_checks.CheckInclusiveLanguage(

mock_input_api,

MockOutputApi(),

excluded_directories_relative_path=['exempt.txt'],

non_inclusive_terms=PRESUBMIT._NON_INCLUSIVE_TERMS,

source_file_filter=lambda f: not PRESUBMIT._IsVendoredCratesFile(

f)))

self.assertEqual(1, len(results_fp))

def testCheckCommonBypassesVendoredCrates(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile('chrome/browser/ui/foo.cc', ['int x = 1;']),

MockFile(

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs',

['pub fn foo() {}']),

]

mock_input_api.canned_checks.PanProjectChecks = mock.Mock(

return_value=[])

mock_input_api.canned_checks.CheckInclusiveLanguage = mock.Mock(

return_value=[])

mock_input_api.canned_checks.CheckChangeHasNoTabs = mock.Mock(

return_value=[])

mock_input_api.canned_checks.CheckOwnersDirMetadataExclusive = (

mock.Mock(return_value=[]))

mock_input_api.canned_checks.CheckNoNewMetadataInOwners = mock.Mock(

return_value=[])

mock_input_api.canned_checks.CheckNewDEPSHooksHasRequiredReviewers = (

mock.Mock(return_value=[]))

mock_input_api.canned_checks.CheckValidHostsInDEPSOnUpload = (

mock.Mock(return_value=[]))

PRESUBMIT.CheckCommon(mock_input_api, MockOutputApi())

mock_input_api.canned_checks.PanProjectChecks.assert_called_once()

call_args, call_kwargs = (

mock_input_api.canned_checks.PanProjectChecks.call_args)

self.assertIs(call_args[0], mock_input_api)

excluded_paths = call_kwargs.get('excluded_paths')

self.assertIn(PRESUBMIT._VENDORED_CRATES_PATH_RE, excluded_paths)

(mock_input_api.canned_checks.CheckInclusiveLanguage

.assert_called_once())

call_args, call_kwargs = (

mock_input_api.canned_checks.CheckInclusiveLanguage.call_args)

self.assertIs(call_args[0], mock_input_api)

source_file_filter = call_kwargs.get('source_file_filter')

self.assertIsNotNone(source_file_filter)

self.assertTrue(

source_file_filter(MockFile('chrome/browser/ui/foo.cc', [])))

serde_path = (

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs')

self.assertFalse(source_file_filter(MockFile(serde_path, [])))

def testCheckGoogleSupportAnswerUrlBypassesVendoredCrates(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile(

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs',

['support.google.com/chrome/answer/123']),

MockFile('chrome/browser/ui/foo.cc',

['support.google.com/chrome/answer/123']),

]

results = PRESUBMIT.CheckGoogleSupportAnswerUrlOnUpload(

mock_input_api, MockOutputApi())

self.assertEqual(1, len(results))

self.assertIn('chrome/browser/ui/foo.cc', results[0].items[0])

def testCheckTodoBugReferencesBypassesVendoredCrates(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile(

'third_party/rust/chromium_crates_io/vendor/serde/src/lib.rs',

['// TODO(123): fix']),

MockFile('third_party/rust/other_store/vendor/foo/src/lib.rs',

['// TODO(456): fix']),

MockFile('chrome/browser/ui/foo.cc', ['// TODO(789): fix']),

]

results = PRESUBMIT.CheckTodoBugReferences(mock_input_api,

MockOutputApi())

self.assertEqual(1, len(results))

def testBadRejFile(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile('some/path/foo.cc', ''),

MockFile('some/path/foo.cc.rej', ''),

MockFile('some/path2/bar.h.rej', ''),

]

results = PRESUBMIT.CheckPatchFiles(mock_input_api, MockOutputApi())

self.assertEqual(1, len(results))

self.assertEqual(2, len(results[0].items))

self.assertIn('foo.cc.rej', results[0].items[0])

self.assertIn('bar.h.rej', results[0].items[1])

def testBadOrigFile(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile('other/path/qux.h.orig', ''),

MockFile('other/path/qux.h', ''),

MockFile('other/path/qux.cc', ''),

]

results = PRESUBMIT.CheckPatchFiles(mock_input_api, MockOutputApi())

self.assertEqual(1, len(results))

self.assertEqual(1, len(results[0].items))

self.assertIn('qux.h.orig', results[0].items[0])

def testGoodFiles(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile('other/path/qux.h', ''),

MockFile('other/path/qux.cc', ''),

]

results = PRESUBMIT.CheckPatchFiles(mock_input_api, MockOutputApi())

def testGoodFiles(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

# The build-config macros are allowed to be used in build_config.h

# without including itself.

MockFile('build/build_config.h',

['// comment', '#if defined(COMPILER_GCC)']),

MockFile('other/path/foo.cc', [

'#include "build/build_config.h"',

'#if defined(COMPILER_GCC)',

]),

MockFile('other/path/foo.h', [

'#include "build/build_config.h"',

'#if defined(COMPILER_GCC)',

]),

# Primary header includes build_config.h.

MockFile('other/path/bar.h', ['#include "build/build_config.h"']),

MockFile('other/path/bar.cc',

['// comment', '#if defined(COMPILER_GCC)']),

# Third-party libraries (except Blink) are excluded.

MockFile('third_party/foo/foo.h',

['// comment', '#if defined(COMPILER_GCC)']),

MockFile('third_party/foo/foo.cc',

['// comment', '#if defined(COMPILER_GCC)']),

MockFile('ios/third_party/foo/foo.h',

['// comment', '#if defined(COMPILER_GCC)']),

MockFile('ios/third_party/foo/foo.cc',

['// comment', '#if defined(COMPILER_GCC)']),

# Non-C++ files are not checked.

MockFile('other/path/not_checked.txt',

['// comment', '#if defined(COMPILER_GCC)']),

]

results = PRESUBMIT.CheckBuildConfigMacrosWithoutInclude(

mock_input_api, MockOutputApi())

self.assertEqual(0, len(results))

def testBadFiles(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile('other/path/foo.h',

['// comment', '#if defined(COMPILER_GCC)']),

MockFile('other/path/foo.cc',

['// comment', '#if defined(COMPILER_GCC)']),

# Blink is not excluded, despite being in third-party.

MockFile('third_party/blink/foo.h',

['// comment', '#if defined(COMPILER_GCC)']),

MockFile('third_party/blink/foo.cc',

['// comment', '#if defined(COMPILER_GCC)']),

]

results = PRESUBMIT.CheckBuildConfigMacrosWithoutInclude(

mock_input_api, MockOutputApi())

self.assertEqual(1, len(results))

self.assertIn('other/path/foo.h:1 COMPILER_GCC', results[0].message)

self.assertIn('other/path/foo.cc:1 COMPILER_GCC', results[0].message)

self.assertIn('third_party/blink/foo.h:1 COMPILER_GCC',

results[0].message)

self.assertIn('third_party/blink/foo.cc:1 COMPILER_GCC',

def testGoodFiles(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

# The check is not smart enough to figure out which definitions correspond

# to which header.

MockFile('other/path/foo.h', ['#include <string>', 'std::vector']),

# The check is not smart enough to do IWYU.

MockFile('other/path/bar.h',

['#include "base/check.h"', 'std::vector']),

MockFile('other/path/qux.h',

['#include "base/stl_util.h"', 'foobar']),

MockFile('other/path/baz.h',

['#include "set/vector.h"', 'bazzab']),

# Third-party libraries (except Blink) are excluded.

MockFile('third_party/foo/foo.h',

['#include <vector>', 'no_std_namespace']),

MockFile('ios/third_party/foo/foo.h',

['#include <vector>', 'no_std_namespace']),

# The check is only for header files.

MockFile('other/path/not_checked.cc',

['#include <vector>', 'bazbaz']),

]

results = PRESUBMIT.CheckForSuperfluousStlIncludesInHeaders(

mock_input_api, MockOutputApi())

self.assertEqual(0, len(results))

def testBadFiles(self):

mock_input_api = MockInputApi()

mock_input_api.files = [

MockFile('other/path/foo.h', ['#include <vector>', 'vector']),

MockFile(

'other/path/bar.h',

['#include <limits>', '#include <set>', 'no_std_namespace']),

# Blink is not excluded, despite being in third-party.

MockFile('third_party/blink/foo.h',

['#include <vector>', 'no_std_namespace']),

]

results = PRESUBMIT.CheckForSuperfluousStlIncludesInHeaders(

mock_input_api, MockOutputApi())

self.assertEqual(1, len(results))

self.assertIn('foo.h: Includes STL', results[0].message)

self.assertIn('bar.h: Includes STL', results[0].message)

self.assertIn('third_party/blink/foo.h: Includes STL',

def testSingletonInArbitraryHeader(self):

diff_singleton_h = [

'base::subtle::AtomicWord '

'base::Singleton<Type, Traits, DifferentiatingType>::'

]

diff_foo_h = [

'// base::Singleton<Foo> in comment.',

'friend class base::Singleton<Foo>'

]

diff_foo2_h = [' //Foo* bar = base::Singleton<Foo>::get();']

diff_bad_h = ['Foo* foo = base::Singleton<Foo>::get();']

mock_input_api = MockInputApi()

mock_input_api.files = [

MockAffectedFile('base/memory/singleton.h', diff_singleton_h),

MockAffectedFile('foo.h', diff_foo_h),

MockAffectedFile('foo2.h', diff_foo2_h),

MockAffectedFile('bad.h', diff_bad_h)

]

warnings = PRESUBMIT.CheckSingletonInHeaders(mock_input_api,

MockOutputApi())

self.assertEqual(1, len(warnings))

self.assertEqual(1, len(warnings[0].items))

self.assertEqual('error', warnings[0].type)

self.assertIn('Found base::Singleton<T>', warnings[0].message)

def testSingletonInCC(self):

diff_cc = ['Foo* foo = base::Singleton<Foo>::get();']

mock_input_api = MockInputApi()

mock_input_api.files = [MockAffectedFile('some/path/foo.cc', diff_cc)]

warnings = PRESUBMIT.CheckSingletonInHeaders(mock_input_api,

MockOutputApi())

def testDeprecatedOSMacroNames(self):

lines = [

'#if defined(OS_WIN)', ' #elif defined(OS_WINDOW)',

' # if defined(OS_MAC) || defined(OS_CHROME)'

]

errors = PRESUBMIT._CheckForDeprecatedOSMacrosInFile(

MockInputApi(), MockFile('some/path/foo_platform.cc', lines))

self.assertEqual(len(lines) + 1, len(errors))

def testInvalidIfDefinedMacroNames(self):

lines = [

'#if defined(TARGET_IPHONE_SIMULATOR)',

'#if !defined(TARGET_IPHONE_SIMULATOR)',

'#elif defined(TARGET_IPHONE_SIMULATOR)',

'#ifdef TARGET_IPHONE_SIMULATOR',

'#elifdef TARGET_IPHONE_SIMULATOR',

' # ifdef TARGET_IPHONE_SIMULATOR',

'# if defined(VALID) || defined(TARGET_IPHONE_SIMULATOR)',

'# else // defined(TARGET_IPHONE_SIMULATOR)',

'#endif // defined(TARGET_IPHONE_SIMULATOR)'

]

errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile(

MockInputApi(), MockFile('some/path/source.mm', lines))

self.assertEqual(len(lines), len(errors))

def testValidIfDefinedMacroNames(self):

lines = [

'#if defined(FOO)', '#ifdef BAR', '#if TARGET_IPHONE_SIMULATOR'

]

errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile(

MockInputApi(), MockFile('some/path/source.cc', lines))

def testUnitTestMacros(self):

lines = [

'#if defined(UNIT_TEST)', '#if defined UNIT_TEST',

'#if !defined(UNIT_TEST)', '#elif defined(UNIT_TEST)',

'#ifdef UNIT_TEST', ' # ifdef UNIT_TEST', '#ifndef UNIT_TEST',

'# if defined(VALID) || defined(UNIT_TEST)',

'# if defined(UNIT_TEST) && defined(VALID)',

'# else // defined(UNIT_TEST)', '#endif // defined(UNIT_TEST)'

]

errors = PRESUBMIT._CheckNoUNIT_TESTInFile(

MockInputApi(), MockFile('some/path/source.cc', lines))

self.assertEqual(len(lines), len(errors))

def testNotUnitTestMacros(self):

lines = [

'// Comment about "#if defined(UNIT_TEST)"',

'/* Comment about #if defined(UNIT_TEST)" */',

'#ifndef UNIT_TEST_H', '#define UNIT_TEST_H',

'#ifndef TEST_UNIT_TEST', '#define TEST_UNIT_TEST',

'#if defined(_UNIT_TEST)', '#if defined(UNIT_TEST_)',

'#ifdef _UNIT_TEST', '#ifdef UNIT_TEST_', '#ifndef _UNIT_TEST',

'#ifndef UNIT_TEST_'

]

errors = PRESUBMIT._CheckNoUNIT_TESTInFile(

MockInputApi(), MockFile('some/path/source.cc', lines))

def testWarning(self):

test_files = [

MockFile('chrome/browser/foo_unittest.cc', [

'#if BUILDFLAG(SUPPORTS_OZONE_WAYLAND)',

'#endif',

]),

MockFile('chrome/browser/bar_browsertest.cc', [

'#if BUILDFLAG(SUPPORTS_OZONE_X11)',

'#endif',

]),

MockFile('content/test/baz_test.cc', [

'BUILDFLAG(SUPPORTS_OZONE_WAYLAND)',

]),

]

input_api = MockInputApi()

input_api.InitFiles(test_files)

warnings = PRESUBMIT.CheckNoOzonePlatformMacrosInTests(

input_api, MockOutputApi())

self.assertEqual(1, len(warnings))

self.assertEqual('warning', warnings[0].type)

self.assertEqual(3, len(warnings[0].items))

self.assertIn(

f'{os.path.normpath("chrome/browser/foo_unittest.cc")}:1',

warnings[0].items[0])

self.assertIn(

f'{os.path.normpath("chrome/browser/bar_browsertest.cc")}:1',

warnings[0].items[1])

self.assertIn(

f'{os.path.normpath("content/test/baz_test.cc")}:1',

warnings[0].items[2])

def testNoWarning(self):

non_test_files = [

MockFile('chrome/browser/foo.cc', [

'#if BUILDFLAG(SUPPORTS_OZONE_WAYLAND)',

'#endif',

]),

MockFile('ui/ozone/platform/wayland/wayland_window.cc', [

'SUPPORTS_OZONE_WAYLAND',

]),

MockFile('chrome/browser/baz_unittest.cc', [

'SUPPORTS_OZONE_WAYLAND',

]),

]

input_api = MockInputApi()

input_api.InitFiles(non_test_files)

warnings = PRESUBMIT.CheckNoOzonePlatformMacrosInTests(

input_api, MockOutputApi())

self.assertEqual(0, len(warnings))

def testCleanTest(self):

clean_test_files = [

MockFile('chrome/browser/foo_unittest.cc', [

'#if BUILDFLAG(IS_CHROMEOS)',

'#endif',

]),

]

input_api = MockInputApi()

input_api.InitFiles(clean_test_files)

warnings = PRESUBMIT.CheckNoOzonePlatformMacrosInTests(

input_api, MockOutputApi())

def testNewSha256FileNoDEPS(self):

input_api = MockInputApi()

input_api.files = [

MockFile('base/tracing/test/data_sha256/new.pftrace.sha256', []),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual(

('You must update the DEPS file when you update a .sha256 file '

'in base/tracing/test/data_sha256'), results[0].message)

def testNewSha256FileSuccess(self):

input_api = MockInputApi()

new_deps = """deps = {

}""".splitlines()

input_api.files = [

MockFile('base/tracing/test/data_sha256/new.pftrace.sha256',

['a1b2c3f4']),

MockFile('DEPS', new_deps,

["deps={'src/base/tracing/test/data':{}}"]),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual(0, len(results))

def testNewSha256FileWrongSha256(self):

input_api = MockInputApi()

new_deps = """deps = {

}""".splitlines()

f = MockFile('base/tracing/test/data_sha256/new.pftrace.sha256',

['a1b2c3f4'])

input_api.files = [

f,

MockFile('DEPS', new_deps,

["deps={'src/base/tracing/test/data':{}}"]),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual(

('No corresponding DEPS entry found for %s. '

'Run `base/tracing/test/test_data.py get_deps --filepath %s` '

'to generate the DEPS entry.' % (f.LocalPath(), f.LocalPath())),

results[0].message)

def testDeleteSha256File(self):

input_api = MockInputApi()

old_deps = """deps = {

}""".splitlines()

f = MockFile('base/tracing/test/data_sha256/new.pftrace.sha256', [],

['a1b2c3f4'],

action='D')

input_api.files = [

f,

MockFile('DEPS', old_deps, old_deps),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual((

'You deleted %s so you must also remove the corresponding DEPS entry.'

% f.LocalPath()), results[0].message)

def testDeleteSha256Success(self):

input_api = MockInputApi()

new_deps = """deps = {

}""".splitlines()

old_deps = """deps = {

}""".splitlines()

f = MockFile('base/tracing/test/data_sha256/new.pftrace.sha256', [],

['a1b2c3f4'],

action='D')

input_api.files = [

f,

MockFile('DEPS', new_deps, old_deps),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

def setUp(self):

self.input_api = input_api = MockInputApi()

input_api.environ = {}

input_api.owners_client = self.FakeOwnersClient()

input_api.gerrit = self.fakeGerrit()

input_api.change.issue = 123

self.mockOwnersAndReviewers('owner', set(['reviewer']))

self.mockListSubmodules([])

def calculate(self, old_include_rules, old_specific_include_rules,

new_include_rules, new_specific_include_rules):

return PRESUBMIT._CalculateAddedDeps(

os.path, 'include_rules = %r\nspecific_include_rules = %r' %

(old_include_rules, old_specific_include_rules),

'include_rules = %r\nspecific_include_rules = %r' %

(new_include_rules, new_specific_include_rules))

def testCalculateAddedDeps(self):

old_include_rules = [

'+base',

'-chrome',

'+content',

'-grit',

'-grit/",',

'+jni/fooblat.h',

'!sandbox',

]

old_specific_include_rules = {

r'compositor\.*': {

'+cc',

},

}

new_include_rules = [

'-ash',

'+base',

'+chrome',

'+components',

'+content',

'+grit',

'+grit/generated_resources.h",',

'+grit/",',

'+jni/fooblat.h',

'+policy',

'+' + os.path.join('third_party', 'WebKit'),

]

new_specific_include_rules = {

r'compositor\.*': {

'+cc',

},

r'widget\.*': {

'+gpu',

},

}

expected = set([

os.path.join('chrome', 'DEPS'),

os.path.join('gpu', 'DEPS'),

os.path.join('components', 'DEPS'),

os.path.join('policy', 'DEPS'),

os.path.join('third_party', 'WebKit', 'DEPS'),

])

self.assertEqual(

expected,

self.calculate(old_include_rules, old_specific_include_rules,

new_include_rules, new_specific_include_rules))

def testCalculateAddedDepsIgnoresPermutations(self):

old_include_rules = [

'+base',

'+chrome',

]

new_include_rules = [

'+chrome',

'+base',

]

self.assertEqual(

set(), self.calculate(old_include_rules, {}, new_include_rules,

{}))

def testFindAddedDepsThatRequireReview(self):

caring = ['new_usages_require_review = True']

self.input_api.InitFiles([

MockAffectedFile('cares/DEPS', caring),

MockAffectedFile('cares/inherits/DEPS', []),

MockAffectedFile('willynilly/DEPS', []),

MockAffectedFile('willynilly/butactually/DEPS', caring),

])

expected = {

'cares': True,

'cares/sub/sub': True,

'cares/inherits': True,

'cares/inherits/sub': True,

'willynilly': False,

'willynilly/butactually': True,

'willynilly/butactually/sub': True,

}

results = PRESUBMIT._FindAddedDepsThatRequireReview(

self.input_api, set(expected))

actual = {k: k in results for k in expected}

self.assertEqual(expected, actual)

class FakeOwnersClient(object):

APPROVED = 'APPROVED'

PENDING = 'PENDING'

returns = {}

def ListOwners(self, *args, **kwargs):

return self.returns.get(self.ListOwners.__name__, '')

def mockListOwners(self, owners):

self.returns[self.ListOwners.__name__] = owners

def GetFilesApprovalStatus(self, *args, **kwargs):

return self.returns.get(self.GetFilesApprovalStatus.__name__, {})

def mockGetFilesApprovalStatus(self, status):

self.returns[self.GetFilesApprovalStatus.__name__] = status

def SuggestOwners(self, *args, **kwargs):

return ['eng1', 'eng2', 'eng3']

class fakeGerrit(object):

def IsOwnersOverrideApproved(self, issue):

return False

def mockOwnersAndReviewers(self, owner, reviewers):

def mock(*args, **kwargs):

return [owner, reviewers]

self.input_api.canned_checks.GetCodereviewOwnerAndReviewers = mock

def mockListSubmodules(self, paths):

def mock(*args, **kwargs):

return paths

self.input_api.ListSubmodules = mock

def testApprovedAdditionalDep(self):

self.input_api.InitFiles([

MockAffectedFile('pdf/DEPS',

['include_rules=["+v8/123", "+foo/bar"]']),

MockAffectedFile('v8/DEPS', ['new_usages_require_review=True']),

# Check that we ignore "DEPS" directories. Note there are real cases

# of directories named "deps/" and, especially for case-insensitive file

# systems we should prevent these from being considered.

MockAffectedFile('foo/bar/DEPS/boofar', ['boofar file contents']),

])

# mark the additional dep as approved.

os_path = self.input_api.os_path

self.input_api.owners_client.mockGetFilesApprovalStatus(

{os_path.join('v8/123', 'DEPS'): self.FakeOwnersClient.APPROVED})

results = PRESUBMIT.CheckAddedDepsHaveTargetApprovals(

self.input_api, MockOutputApi())

# Then, the check should pass.

self.assertEqual([], results)

def testUnapprovedAdditionalDep(self):

self.input_api.InitFiles([

MockAffectedFile('pdf/DEPS', ['include_rules=["+v8/123"]']),

MockAffectedFile('v8/DEPS', ['new_usages_require_review=True']),

])

# pending.

os_path = self.input_api.os_path

self.input_api.owners_client.mockGetFilesApprovalStatus(

{os_path.join('v8/123', 'DEPS'): self.FakeOwnersClient.PENDING})

results = PRESUBMIT.CheckAddedDepsHaveTargetApprovals(

self.input_api, MockOutputApi())

# the check should fail

self.assertIn('You need LGTM', results[0].message)

self.assertIn('+v8/123', results[0].message)

# unless the added dep is from a submodule.

self.mockListSubmodules(['v8'])

results = PRESUBMIT.CheckAddedDepsHaveTargetApprovals(

self.input_api, MockOutputApi())

def testSuccess(self):

input_api = MockInputApi()

filename = 'valid_json.json'

contents = [

'// This is a comment.', '{', ' "key1": ["value1", "value2"],',

' "key2": 3 // This is an inline comment.', '}'

]

input_api.files = [MockFile(filename, contents)]

self.assertIsNone(PRESUBMIT._GetJSONParseError(input_api, filename))

def testFailure(self):

input_api = MockInputApi()

test_data = [

('invalid_json_1.json', ['{ x }'], ['Expecting property name']),

('invalid_json_2.json', ['// Hello world!', '{ "hello": "world }'],

['Unterminated string starting at:']),

(

'invalid_json_3.json',

['{ "a": "b", "c": "d", }'],

# Different errors depending on Python version.

[

'Illegal trailing comma before end of object',

'Expecting property name'

]),

('invalid_json_4.json', ['{ "a": "b" "c": "d" }'],

["Expecting ',' delimiter:"]),

]

input_api.files = [

MockFile(filename, contents)

for (filename, contents, _) in test_data

]

for (filename, _, expected_errors) in test_data:

actual_error = PRESUBMIT._GetJSONParseError(input_api, filename)

self.assertTrue(

any(e in str(actual_error) for e in expected_errors),

f'{filename}: "{expected_errors}" not found in "{actual_error}"'

)

def testNoEatComments(self):

input_api = MockInputApi()

file_with_comments = 'file_with_comments.json'

contents_with_comments = [

'// This is a comment.', '{', ' "key1": ["value1", "value2"],',

' "key2": 3 // This is an inline comment.', '}'

]

file_without_comments = 'file_without_comments.json'

contents_without_comments = [

'{', ' "key1": ["value1", "value2"],', ' "key2": 3', '}'

]

input_api.files = [

MockFile(file_with_comments, contents_with_comments),

MockFile(file_without_comments, contents_without_comments)

]

self.assertIsNotNone(

str(

PRESUBMIT._GetJSONParseError(input_api,

file_with_comments,

eat_comments=False)))

self.assertIsNone(

PRESUBMIT._GetJSONParseError(input_api,

file_without_comments,

def setUp(self):

self._temp_dir = tempfile.TemporaryDirectory()

def tearDown(self):

self._temp_dir.cleanup()

def _WriteTempFile(self, filename, contents):

full_path = os.path.join(self._temp_dir.name, filename)

os.makedirs(os.path.dirname(full_path), exist_ok=True)

with open(full_path, 'w', encoding='utf-8', newline='') as f:

f.write('\n'.join(contents))

return full_path

def _RunIDLParse(self, input_api, filename):

output_api = MockOutputApi()