Enhance RunPylint to use white_list and black_list arguments.

tests/presubmit_unittest.py

 #!/usr/bin/python
 # Copyright (c) 2010 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Unit tests for presubmit_support.py and presubmit_canned_checks.py."""
 
+# pylint is too confused.
+# pylint: disable=E1101,E1103,W0212,W0403
+
 import StringIO
 
 # Fixes include path.
 from super_mox import mox, SuperMoxTestBase
 
 import presubmit_support as presubmit
 # Shortcut.
 presubmit_canned_checks = presubmit.presubmit_canned_checks
 
 
@@ skipping 141 matching lines @@
                          ' STORY =http://foo/  \t',
                          'and some more regular text  \t')
     files = [
       ['A', 'foo/blat.cc'],
       ['M', 'binary.dll'],  # a binary file
       ['A', 'isdir'],  # a directory
       ['?', 'flop/notfound.txt'],  # not found in SVN, still exists locally
       ['D', 'boo/flap.h'],
     ]
     blat = presubmit.os.path.join(self.fake_root_dir, 'foo', 'blat.cc')
-    notfound = presubmit.os.path.join(self.fake_root_dir, 'flop', 'notfound.txt')
+    notfound = presubmit.os.path.join(
+        self.fake_root_dir, 'flop', 'notfound.txt')
     flap = presubmit.os.path.join(self.fake_root_dir, 'boo', 'flap.h')
     binary = presubmit.os.path.join(self.fake_root_dir, 'binary.dll')
     isdir = presubmit.os.path.join(self.fake_root_dir, 'isdir')
     presubmit.os.path.exists(blat).AndReturn(True)
     presubmit.os.path.isdir(blat).AndReturn(False)
     presubmit.os.path.exists(binary).AndReturn(True)
     presubmit.os.path.isdir(binary).AndReturn(False)
     presubmit.os.path.exists(isdir).AndReturn(True)
     presubmit.os.path.isdir(isdir).AndReturn(True)
     presubmit.os.path.exists(notfound).AndReturn(True)
@@ skipping 148 matching lines @@
     presubmit.os.path.isfile(root_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
     presubmit.gclient_utils.FileRead(root_path,
                                      'rU').AndReturn(self.presubmit_text)
     presubmit.gclient_utils.FileRead(haspresubmit_path,
                                      'rU').AndReturn(self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('y\n')
+    input_buf = StringIO.StringIO('y\n')
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(change, False, True, output, input,
-                                            None, False))
+    self.failIf(presubmit.DoPresubmitChecks(
+        change, False, True, output, input_buf, None, False))
     self.assertEqual(output.getvalue().count('!!'), 2)
     self.checkstdout('Running presubmit hooks...\n')
 
   def testDoPresubmitChecksPromptsAfterWarnings(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'NOSUCHKEY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     presubmit_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit', 'PRESUBMIT.py')
     inherit_path = presubmit.os.path.join(self.fake_root_dir,
                                           self._INHERIT_SETTINGS)
-    for i in range(2):
+    for _ in range(2):
       presubmit.os.path.isfile(inherit_path).AndReturn(False)
       presubmit.os.path.isfile(presubmit_path).AndReturn(True)
       presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
       presubmit.gclient_utils.FileRead(presubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
       presubmit.gclient_utils.FileRead(haspresubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('n\n')  # say no to the warning
+    input_buf = StringIO.StringIO('n\n')  # say no to the warning
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(change, False, True, output, input,
-                                            None, True))
+    self.failIf(presubmit.DoPresubmitChecks(
+        change, False, True, output, input_buf, None, True))
     self.assertEqual(output.getvalue().count('??'), 2)
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('y\n')  # say yes to the warning
-    self.failUnless(presubmit.DoPresubmitChecks(change, False, True, output,
-                                                input, None, True))
+    input_buf = StringIO.StringIO('y\n')  # say yes to the warning
+    self.failUnless(presubmit.DoPresubmitChecks(
+        change, False, True, output, input_buf, None, True))
     self.assertEquals(output.getvalue().count('??'), 2)
     self.checkstdout('Running presubmit hooks...\nRunning presubmit hooks...\n')
 
   def testDoPresubmitChecksNoWarningPromptIfErrors(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'NOSUCHKEY=http://tracker/123',
                          'REALLYNOSUCHKEY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     presubmit_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit',
                              'PRESUBMIT.py')
     inherit_path = presubmit.os.path.join(self.fake_root_dir,
                                           self._INHERIT_SETTINGS)
     presubmit.os.path.isfile(inherit_path).AndReturn(False)
     presubmit.os.path.isfile(presubmit_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
     presubmit.gclient_utils.FileRead(presubmit_path, 'rU'
                                      ).AndReturn(self.presubmit_text)
     presubmit.gclient_utils.FileRead(haspresubmit_path, 'rU').AndReturn(
         self.presubmit_text)
     presubmit.random.randint(0, 4).AndReturn(1)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO()  # should be unused
+    input_buf = StringIO.StringIO()  # should be unused
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(change, False, True, output, input,
-                                            None, False))
+    self.failIf(presubmit.DoPresubmitChecks(
+        change, False, True, output, input_buf, None, False))
     self.assertEqual(output.getvalue().count('??'), 2)
     self.assertEqual(output.getvalue().count('XX!!XX'), 2)
     self.assertEqual(output.getvalue().count('(y/N)'), 0)
     self.checkstdout('Running presubmit hooks...\n')
 
   def testDoDefaultPresubmitChecksAndFeedback(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'STORY=http://tracker/123')
@@ skipping 11 matching lines @@
     presubmit.os.path.isfile(inherit_path).AndReturn(False)
     presubmit.os.path.isfile(join(self.fake_root_dir, 'PRESUBMIT.py')
         ).AndReturn(False)
     presubmit.os.path.isfile(join(self.fake_root_dir,
                                   'haspresubmit',
                                   'PRESUBMIT.py')).AndReturn(False)
     presubmit.random.randint(0, 4).AndReturn(0)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('y\n')
+    input_buf = StringIO.StringIO('y\n')
     # Always fail.
     change = presubmit.Change('mychange', '\n'.join(description_lines),
                               self.fake_root_dir, files, 0, 0)
-    self.failIf(presubmit.DoPresubmitChecks(change, False, True, output, input,
-                                            DEFAULT_SCRIPT, False))
+    self.failIf(presubmit.DoPresubmitChecks(
+        change, False, True, output, input_buf, DEFAULT_SCRIPT, False))
     text = ('Warning, no presubmit.py found.\n'
             'Running default presubmit script.\n'
             '** Presubmit ERRORS **\n!!\n\n'
             'Was the presubmit check useful? Please send feedback & hate mail '
             'to maruel@chromium.org!\n')
     self.assertEquals(output.getvalue(), text)
     self.checkstdout('Running presubmit hooks...\n')
 
   def testDirectoryHandling(self):
     files = [
@@ skipping 47 matching lines @@
 def CheckChangeOnCommit(input_api, output_api):
   raise Exception("Test error")
 """
     presubmit.random.randint(0, 4).AndReturn(1)
     inherit_path = presubmit.os.path.join(self.fake_root_dir,
                                           self._INHERIT_SETTINGS)
     presubmit.os.path.isfile(inherit_path).AndReturn(False)
     self.mox.ReplayAll()
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('y\n')
+    input_buf = StringIO.StringIO('y\n')
     change = presubmit.Change(
         'foo', "Blah Blah\n\nSTORY=http://tracker.com/42\nBUG=boo\n",
         self.fake_root_dir, None, 0, 0)
-    self.failUnless(presubmit.DoPresubmitChecks(change, False, True, output,
-                                                input, DEFAULT_SCRIPT, False))
+    self.failUnless(presubmit.DoPresubmitChecks(
+        change, False, True, output, input_buf, DEFAULT_SCRIPT, False))
     self.assertEquals(output.getvalue(),
                       ('Warning, no presubmit.py found.\n'
                        'Running default presubmit script.\n'
                        '** Presubmit Messages **\n'
                        'http://tracker.com/42\n\n'))
     self.checkstdout('Running presubmit hooks...\n')
 
   def testGetTrySlavesExecuter(self):
     self.mox.ReplayAll()
 
@@ skipping 275 matching lines @@
                           presubmit.normpath(item[1][i]))
       # Same number of expected results.
       self.assertEquals(sorted([f.LocalPath().replace(presubmit.os.sep, '/')
                                 for f in results]),
                         sorted(item[1]))
 
   def testCustomFilter(self):
     def FilterSourceFile(affected_file):
       return 'a' in affected_file.LocalPath()
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee')]
-    for (action, item) in files:
+    for _, item in files:
       item = presubmit.os.path.join(self.fake_root_dir, item)
       presubmit.os.path.exists(item).AndReturn(True)
       presubmit.os.path.isdir(item).AndReturn(False)
       presubmit.scm.SVN.GetFileProperty(item, 'svn:mime-type').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '', self.fake_root_dir, files, 0,
                                  0)
     input_api = presubmit.InputApi(change,
                                    presubmit.os.path.join(self.fake_root_dir,
                                                           'PRESUBMIT.py'),
                                    False)
     got_files = input_api.AffectedSourceFiles(FilterSourceFile)
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
     self.assertEquals(got_files[1].LocalPath(), 'eeabee')
 
   def testLambdaFilter(self):
     white_list = presubmit.InputApi.DEFAULT_BLACK_LIST + (r".*?a.*?",)
     black_list = [r".*?b.*?"]
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee'), ('M', 'eecaee')]
-    for (action, item) in files:
+    for _, item in files:
       item = presubmit.os.path.join(self.fake_root_dir, item)
       presubmit.os.path.exists(item).AndReturn(True)
       presubmit.os.path.isdir(item).AndReturn(False)
       presubmit.scm.SVN.GetFileProperty(item, 'svn:mime-type').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.SvnChange('mychange', '', self.fake_root_dir, files, 0,
                                  0)
     input_api = presubmit.InputApi(change, './PRESUBMIT.py', False)
     # Sample usage of overiding the default white and black lists.
@@ skipping 68 matching lines @@
     presubmit.gclient_utils.FileRead(path, 'x').AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
     input_api.ReadFile(path, 'x')
 
   def testReadFileAffectedFileDenied(self):
-    file = presubmit.AffectedFile('boo', 'M', 'Unrelated')
+    fileobj = presubmit.AffectedFile('boo', 'M', 'Unrelated')
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
-    self.assertRaises(IOError, input_api.ReadFile, file, 'x')
+    self.assertRaises(IOError, input_api.ReadFile, fileobj, 'x')
 
   def testReadFileAffectedFileAccepted(self):
-    file = presubmit.AffectedFile('AA/boo', 'M', self.fake_root_dir)
-    presubmit.gclient_utils.FileRead(file.AbsoluteLocalPath(), 'x'
+    fileobj = presubmit.AffectedFile('AA/boo', 'M', self.fake_root_dir)
+    presubmit.gclient_utils.FileRead(fileobj.AbsoluteLocalPath(), 'x'
                                      ).AndReturn(None)
     self.mox.ReplayAll()
 
     change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
                               0, 0)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
-    input_api.ReadFile(file, 'x')
+    input_api.ReadFile(fileobj, 'x')
 
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'MailTextResult', 'PresubmitError', 'PresubmitNotifyResult',
       'PresubmitPromptWarning', 'PresubmitResult',
     ]
@@ skipping 21 matching lines @@
     error = presubmit.OutputApi.PresubmitError('!!!')
     self.failIf(error._Handle(output, unused_input))
     self.failUnless(output.getvalue().count('!!!'))
 
     output = StringIO.StringIO()
     notify = presubmit.OutputApi.PresubmitNotifyResult('?see?')
     self.failUnless(notify._Handle(output, unused_input))
     self.failUnless(output.getvalue().count('?see?'))
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('y')
+    input_buf = StringIO.StringIO('y')
     warning = presubmit.OutputApi.PresubmitPromptWarning('???')
-    self.failUnless(warning._Handle(output, input))
+    self.failUnless(warning._Handle(output, input_buf))
     self.failUnless(output.getvalue().count('???'))
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('n')
+    input_buf = StringIO.StringIO('n')
     warning = presubmit.OutputApi.PresubmitPromptWarning('???')
-    self.failIf(warning._Handle(output, input))
+    self.failIf(warning._Handle(output, input_buf))
     self.failUnless(output.getvalue().count('???'))
 
     output = StringIO.StringIO()
-    input = StringIO.StringIO('\n')
+    input_buf = StringIO.StringIO('\n')
     warning = presubmit.OutputApi.PresubmitPromptWarning('???')
-    self.failIf(warning._Handle(output, input))
+    self.failIf(warning._Handle(output, input_buf))
     self.failUnless(output.getvalue().count('???'))
 
 
 class AffectedFileUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPath', 'Action', 'IsDirectory', 'IsTextFile', 'LocalPath',
       'NewContents', 'OldContents', 'OldFileTempPath', 'Property', 'ServerPath',
     ]
@@ skipping 40 matching lines @@
   def testIsDirectory(self):
     presubmit.os.path.exists('foo.cc').AndReturn(True)
     presubmit.os.path.isdir('foo.cc').AndReturn(True)
     self.mox.ReplayAll()
     affected_file = presubmit.SvnAffectedFile('foo.cc', 'A')
     # Verify cache coherency.
     self.failUnless(affected_file.IsDirectory())
     self.failUnless(affected_file.IsDirectory())
 
   def testIsTextFile(self):
-    list = [presubmit.SvnAffectedFile('foo/blat.txt', 'M'),
+    files = [presubmit.SvnAffectedFile('foo/blat.txt', 'M'),
             presubmit.SvnAffectedFile('foo/binary.blob', 'M'),
             presubmit.SvnAffectedFile('blat/flop.txt', 'D')]
     blat = presubmit.os.path.join('foo', 'blat.txt')
     blob = presubmit.os.path.join('foo', 'binary.blob')
     presubmit.os.path.exists(blat).AndReturn(True)
     presubmit.os.path.isdir(blat).AndReturn(False)
     presubmit.os.path.exists(blob).AndReturn(True)
     presubmit.os.path.isdir(blob).AndReturn(False)
     presubmit.scm.SVN.GetFileProperty(blat, 'svn:mime-type').AndReturn(None)
     presubmit.scm.SVN.GetFileProperty(blob, 'svn:mime-type'
         ).AndReturn('application/octet-stream')
     self.mox.ReplayAll()
 
-    output = filter(lambda x: x.IsTextFile(), list)
+    output = filter(lambda x: x.IsTextFile(), files)
     self.failUnless(len(output) == 1)
-    self.failUnless(list[0] == output[0])
+    self.failUnless(files[0] == output[0])
 
 
 class GclChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     members = [
         'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
         'DescriptionText', 'FullDescriptionText', 'LocalPaths', 'Name',
         'RepositoryRoot', 'RightHandSideLines', 'ServerPaths',
         'issue', 'patchset', 'scm', 'tags',
     ]
@@ skipping 111 matching lines @@
     input_api2.ReadFile(affected_file2, 'rb').AndReturn(content2)
     affected_file2.LocalPath().AndReturn('bar.cc')
     self.mox.ReplayAll()
 
     results = check(input_api1, presubmit.OutputApi)
     self.assertEquals(results, [])
     results2 = check(input_api2, presubmit.OutputApi)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
-  def SvnPropertyTest(self, check, property, value1, value2, committing,
+  def SvnPropertyTest(self, check, property_name, value1, value2, committing,
                       error_type, use_source_file):
     change1 = presubmit.SvnChange('mychange', '', self.fake_root_dir, [], 0, 0)
     input_api1 = self.MockInputApi(change1, committing)
     files1 = [
       presubmit.SvnAffectedFile('foo/bar.cc', 'A'),
       presubmit.SvnAffectedFile('foo.cc', 'M'),
     ]
     if use_source_file:
       input_api1.AffectedSourceFiles(None).AndReturn(files1)
     else:
       input_api1.AffectedFiles(include_deleted=False).AndReturn(files1)
     presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo/bar.cc'),
-                                      property).AndReturn(value1)
+                                      property_name).AndReturn(value1)
     presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo.cc'),
-                                      property).AndReturn(value1)
+                                      property_name).AndReturn(value1)
     change2 = presubmit.SvnChange('mychange', '', self.fake_root_dir, [], 0, 0)
     input_api2 = self.MockInputApi(change2, committing)
     files2 = [
       presubmit.SvnAffectedFile('foo/bar.cc', 'A'),
       presubmit.SvnAffectedFile('foo.cc', 'M'),
     ]
     if use_source_file:
       input_api2.AffectedSourceFiles(None).AndReturn(files2)
     else:
       input_api2.AffectedFiles(include_deleted=False).AndReturn(files2)
 
     presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo/bar.cc'),
-                                      property).AndReturn(value2)
+                                      property_name).AndReturn(value2)
     presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo.cc'),
-                                      property).AndReturn(value2)
+                                      property_name).AndReturn(value2)
     self.mox.ReplayAll()
 
     results1 = check(input_api1, presubmit.OutputApi, None)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi, None)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
   def testCannedCheckChangeHasBugField(self):
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasBugField,
@@ skipping 108 matching lines @@
     results1 = presubmit_canned_checks.CheckChangeHasNoTabs(input_api1,
         presubmit.OutputApi, None)
     self.assertEquals(len(results1), 1)
     self.assertEquals(results1[0].__class__,
         presubmit.OutputApi.PresubmitPromptWarning)
     self.assertEquals(results1[0]._long_text,
         'makefile.foo, line 46')
 
 
   def testCannedCheckLongLines(self):
-    check = lambda x,y,z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
+    check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
     self.ContentTest(check, '', 'blah blah blah',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckChangeSvnEolStyleCommit(self):
     # Test CheckSvnProperty at the same time.
     self.SvnPropertyTest(presubmit_canned_checks.CheckChangeSvnEolStyle,
                          'svn:eol-style', 'LF', '', True,
                          presubmit.OutputApi.PresubmitError, True)
 
   def testCheckChangeSvnEolStyleUpload(self):
     self.SvnPropertyTest(presubmit_canned_checks.CheckChangeSvnEolStyle,
                          'svn:eol-style', 'LF', '', False,
                          presubmit.OutputApi.PresubmitNotifyResult, True)
 
-  def _LicenseCheck(self, text, license, committing, expected_result, **kwargs):
+  def _LicenseCheck(self, text, license_text, committing, expected_result,
+      **kwargs):
     change = self.mox.CreateMock(presubmit.SvnChange)
     change.scm = 'svn'
     input_api = self.MockInputApi(change, committing)
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api.AffectedSourceFiles(42).AndReturn([affected_file])
     input_api.ReadFile(affected_file, 'rb').AndReturn(text)
     if expected_result:
       affected_file.LocalPath().AndReturn('bleh')
 
     self.mox.ReplayAll()
     result = presubmit_canned_checks.CheckLicense(
-                 input_api, presubmit.OutputApi, license, source_file_filter=42,
+                 input_api, presubmit.OutputApi, license_text,
+                 source_file_filter=42,
                  **kwargs)
     if expected_result:
       self.assertEqual(len(result), 1)
       self.assertEqual(result[0].__class__, expected_result)
     else:
       self.assertEqual(result, [])
 
   def testCheckLicenseSuccess(self):
     text = (
         "#!/bin/python\n"
         "# Copyright (c) 2037 Nobody.\n"
         "# All Rights Reserved.\n"
         "print 'foo'\n"
     )
-    license = (
+    license_text = (
         r".*? Copyright \(c\) 2037 Nobody." "\n"
         r".*? All Rights Reserved\." "\n"
     )
-    self._LicenseCheck(text, license, True, None)
+    self._LicenseCheck(text, license_text, True, None)
 
   def testCheckLicenseFailCommit(self):
     text = (
         "#!/bin/python\n"
         "# Copyright (c) 2037 Nobody.\n"
         "# All Rights Reserved.\n"
         "print 'foo'\n"
     )
-    license = (
+    license_text = (
         r".*? Copyright \(c\) 0007 Nobody." "\n"
         r".*? All Rights Reserved\." "\n"
     )
-    self._LicenseCheck(text, license, True,
+    self._LicenseCheck(text, license_text, True,
                        presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckLicenseFailUpload(self):
     text = (
         "#!/bin/python\n"
         "# Copyright (c) 2037 Nobody.\n"
         "# All Rights Reserved.\n"
         "print 'foo'\n"
     )
-    license = (
+    license_text = (
         r".*? Copyright \(c\) 0007 Nobody." "\n"
         r".*? All Rights Reserved\." "\n"
     )
-    self._LicenseCheck(text, license, False,
+    self._LicenseCheck(text, license_text, False,
                        presubmit.OutputApi.PresubmitNotifyResult)
 
   def testCheckLicenseEmptySuccess(self):
     text = ''
-    license = (
+    license_text = (
         r".*? Copyright \(c\) 2037 Nobody." "\n"
         r".*? All Rights Reserved\." "\n"
     )
-    self._LicenseCheck(text, license, True, None, accept_empty_files=True)
+    self._LicenseCheck(text, license_text, True, None, accept_empty_files=True)
 
   def testCannedCheckSvnAccidentalSubmission(self):
     modified_dir_file = 'foo/'
     accidental_submssion_file = 'foo/bar.cc'
 
     change = self.mox.CreateMock(presubmit.SvnChange)
     change.scm = 'svn'
     change.GetModifiedFiles().AndReturn([modified_dir_file])
     change.GetAllModifiedFiles().AndReturn([modified_dir_file,
                                             accidental_submssion_file])
@@ skipping 281 matching lines @@
     results = presubmit_canned_checks.CheckBuildbotPendingBuilds(
         input_api, presubmit.OutputApi, 'uurl', 2, ('foo'))
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
         presubmit.OutputApi.PresubmitNotifyResult)
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()