Add author to Change object. Don't set it yet.

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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,R0201,W0212,W0403
 
@@ skipping 255 matching lines @@
     presubmit.scm.SVN.CaptureInfo(binary).AndReturn(
         {'URL': 'svn:/foo/binary.dll'})
     presubmit.scm.SVN.CaptureInfo(notfound).AndReturn({})
     presubmit.scm.SVN.CaptureInfo(flap).AndReturn(
             {'URL': 'svn:/foo/boo/flap.h'})
     presubmit.scm.SVN.GenerateDiff([blat]).AndReturn(self.presubmit_diffs)
     presubmit.scm.SVN.GenerateDiff([notfound]).AndReturn(self.presubmit_diffs)
 
     self.mox.ReplayAll()
 
-    change = presubmit.SvnChange('mychange', '\n'.join(description_lines),
-                                 self.fake_root_dir, files, 0, 0)
+    change = presubmit.SvnChange(
+        'mychange', '\n'.join(description_lines),

[Dirk Pranke, 2011/04/12 20:49:24]

Nit: if you're going to 1-per-line, maybe this should be on two lines?

+        self.fake_root_dir,
+        files,
+        0,
+        0,
+        None)
     self.failUnless(change.Name() == 'mychange')
     self.failUnless(change.DescriptionText() ==
                     'Hello there\nthis is a change\nand some more regular text')
     self.failUnless(change.FullDescriptionText() ==
                     '\n'.join(description_lines))
 
     self.failUnless(change.BUG == '123')
     self.failUnless(change.STORY == 'http://foo/')
     self.failUnless(change.BLEH == None)
 
@@ skipping 48 matching lines @@
   def testExecPresubmitScript(self):
     description_lines = ('Hello there',
                          'this is a change',
                          'STORY=http://tracker/123')
     files = [
       ['A', 'foo\\blat.cc'],
     ]
     fake_presubmit = presubmit.os.path.join(self.fake_root_dir, 'PRESUBMIT.py')
     self.mox.ReplayAll()
 
-    change = presubmit.Change('mychange', '\n'.join(description_lines),
-                              self.fake_root_dir, files, 0, 0)
+    change = presubmit.Change(

[Dirk Pranke, 2011/04/12 20:49:24]

maybe you should pull this into a helper routine (e.g., get_change()) with
optional params to specify which parameters you care about?

[M-A Ruel, 2011/04/12 23:13:24]

I thought about that but didn't feel like doing it this time. Maybe next time.
:)

+        'mychange',
+        '\n'.join(description_lines),
+        self.fake_root_dir,
+        files,
+        0,
+        0,
+        None)
     executer = presubmit.PresubmitExecuter(change, False, False, None, False)
     self.failIf(executer.ExecPresubmitScript('', fake_presubmit))
     # No error if no on-upload entry point
     self.failIf(executer.ExecPresubmitScript(
       ('def CheckChangeOnCommit(input_api, output_api):\n'
        '  return (output_api.PresubmitError("!!"))\n'),
       fake_presubmit
     ))
 
     executer = presubmit.PresubmitExecuter(change, True, False, None, False)
@@ skipping 50 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()
 
     input_buf = StringIO.StringIO('y\n')
-    change = presubmit.Change('mychange', '\n'.join(description_lines),
-                              self.fake_root_dir, files, 0, 0)
+    change = presubmit.Change(
+        'mychange',
+        '\n'.join(description_lines),
+        self.fake_root_dir,
+        files,
+        0,
+        0,
+        None)
     output = presubmit.DoPresubmitChecks(
         change, False, True, None, input_buf, None, False, False, None)
     self.failIf(output.should_continue())
     self.assertEqual(output.getvalue().count('!!'), 2)
     self.assertEqual(output.getvalue().count(
         'Running presubmit upload checks ...\n'), 1)
 
   def testDoPresubmitChecksPromptsAfterWarnings(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
@@ skipping 12 matching lines @@
       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()
 
     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)
+    change = presubmit.Change(
+        'mychange',
+        '\n'.join(description_lines),
+        self.fake_root_dir,
+        files,
+        0,
+        0,
+        None)
     output = presubmit.DoPresubmitChecks(
         change, False, True, None, input_buf, None, True, False, None)
     self.failIf(output.should_continue())
     self.assertEqual(output.getvalue().count('??'), 2)
 
     input_buf = StringIO.StringIO('y\n')  # say yes to the warning
     output = presubmit.DoPresubmitChecks(
         change, False, True, None, input_buf, None, True, False, None)
     self.failUnless(output.should_continue())
     self.assertEquals(output.getvalue().count('??'), 2)
@@ skipping 17 matching lines @@
     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()
 
-    change = presubmit.Change('mychange', '\n'.join(description_lines),
-                              self.fake_root_dir, files, 0, 0)
+    change = presubmit.Change(
+        'mychange',
+        '\n'.join(description_lines),
+        self.fake_root_dir,
+        files,
+        0,
+        0,
+        None)
     output = presubmit.DoPresubmitChecks(change, False, True, None, None,
         None, False, False, None)
     self.assertEqual(output.getvalue().count('??'), 2)
     self.assertEqual(output.getvalue().count('XX!!XX'), 2)
     self.assertEqual(output.getvalue().count('(y/N)'), 0)
     self.assertEqual(output.getvalue().count(
         'Running presubmit upload checks ...\n'), 1)
 
   def testDoDefaultPresubmitChecksAndFeedback(self):
     join = presubmit.os.path.join
@@ skipping 15 matching lines @@
     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()
 
     input_buf = StringIO.StringIO('y\n')
     # Always fail.
-    change = presubmit.Change('mychange', '\n'.join(description_lines),
-                              self.fake_root_dir, files, 0, 0)
+    change = presubmit.Change(
+        'mychange',
+        '\n'.join(description_lines),
+        self.fake_root_dir,
+        files,
+        0,
+        0,
+        None)
     output = presubmit.DoPresubmitChecks(
         change, False, True, None, input_buf, DEFAULT_SCRIPT, False, False,
         None)
     self.failIf(output.should_continue())
     text = ('Running presubmit upload checks ...\n'
             'Warning, no presubmit.py found.\n'
             'Running default presubmit script.\n'
             '\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)
 
   def testDirectoryHandling(self):
     files = [
       ['A', 'isdir'],
       ['A', presubmit.os.path.join('isdir', 'blat.cc')],
     ]
     isdir = presubmit.os.path.join(self.fake_root_dir, 'isdir')
     blat = presubmit.os.path.join(isdir, 'blat.cc')
     presubmit.os.path.exists(isdir).AndReturn(True)
     presubmit.os.path.isdir(isdir).AndReturn(True)
     presubmit.os.path.exists(blat).AndReturn(True)
     presubmit.os.path.isdir(blat).AndReturn(False)
     self.mox.ReplayAll()
 
-    change = presubmit.Change('mychange', 'foo', self.fake_root_dir, files,
-                              0, 0)
+    change = presubmit.Change(
+        'mychange', 'foo', self.fake_root_dir, files, 0, 0, None)
     affected_files = change.AffectedFiles(include_dirs=False)
     self.failUnless(len(affected_files) == 1)
     self.failUnless(affected_files[0].LocalPath().endswith('blat.cc'))
     affected_files_and_dirs = change.AffectedFiles(include_dirs=True)
     self.failUnless(len(affected_files_and_dirs) == 2)
 
   def testTags(self):
     DEFAULT_SCRIPT = """
 def CheckChangeOnUpload(input_api, output_api):
   if input_api.change.tags['BUG'] != 'boo':
@@ skipping 26 matching lines @@
 """
     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_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)
+        'foo',
+        'Blah Blah\n\nSTORY=http://tracker.com/42\nBUG=boo\n',
+        self.fake_root_dir,
+        None,
+        0,
+        0,
+        None)
     self.failUnless(presubmit.DoPresubmitChecks(
         change, False, True, output, input_buf, DEFAULT_SCRIPT, False, False,
         None))
     self.assertEquals(output.getvalue(),
                       ('Running presubmit upload checks ...\n'
                        'Warning, no presubmit.py found.\n'
                        'Running default presubmit script.\n'
                        '\n'
                        '** Presubmit Messages **\n'
                        'http://tracker.com/42\n'
@@ skipping 204 matching lines @@
         'application/octet-stream')
     presubmit.scm.SVN.GetFileProperty(weird, 'svn:mime-type').AndReturn(None)
     presubmit.scm.SVN.GetFileProperty(another, 'svn:mime-type').AndReturn(None)
     presubmit.scm.SVN.GetFileProperty(third_party, 'svn:mime-type'
         ).AndReturn(None)
     presubmit.scm.SVN.GenerateDiff([blat]).AndReturn(self.presubmit_diffs)
     presubmit.scm.SVN.GenerateDiff([another]).AndReturn(self.presubmit_diffs)
 
     self.mox.ReplayAll()
 
-    change = presubmit.SvnChange('mychange', '\n'.join(description_lines),
-                                 self.fake_root_dir, files, 0, 0)
+    change = presubmit.SvnChange(
+        'mychange',
+        '\n'.join(description_lines),
+        self.fake_root_dir,
+        files,
+        0,
+        0,
+        None)
     input_api = presubmit.InputApi(
         change,
         join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'),
         False, False, None, False)
     # Doesn't filter much
     got_files = input_api.AffectedFiles()
     self.assertEquals(len(got_files), 7)
     self.assertEquals(got_files[0].LocalPath(), presubmit.normpath(files[0][1]))
     self.assertEquals(got_files[1].LocalPath(), presubmit.normpath(files[1][1]))
     self.assertEquals(got_files[2].LocalPath(), presubmit.normpath(files[2][1]))
@@ skipping 96 matching lines @@
     def FilterSourceFile(affected_file):
       return 'a' in affected_file.LocalPath()
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee')]
     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)
+    change = presubmit.SvnChange(
+        'mychange', '', self.fake_root_dir, files, 0, 0, None)
     input_api = presubmit.InputApi(
         change,
         presubmit.os.path.join(self.fake_root_dir, 'PRESUBMIT.py'),
         False, False, None, 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 _, 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)
+    change = presubmit.SvnChange(
+        'mychange', '', self.fake_root_dir, files, 0, 0, None)
     input_api = presubmit.InputApi(
         change, './PRESUBMIT.py', False, False, None, False)
     # Sample usage of overiding the default white and black lists.
     got_files = input_api.AffectedSourceFiles(
         lambda x: input_api.FilterSourceFile(x, white_list, black_list))
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
     self.assertEquals(got_files[1].LocalPath(), 'eecaee')
 
   def testGetAbsoluteLocalPath(self):
     join = presubmit.os.path.join
     normpath = presubmit.normpath
     # Regression test for bug of presubmit stuff that relies on invoking
     # SVN (e.g. to get mime type of file) not working unless gcl invoked
     # from the client root (e.g. if you were at 'src' and did 'cd base' before
     # invoking 'gcl upload' it would fail because svn wouldn't find the files
     # the presubmit script was asking about).
     files = [
       ['A', 'isdir'],
       ['A', join('isdir', 'blat.cc')],
       ['M', join('elsewhere', 'ouf.cc')],
     ]
     self.mox.ReplayAll()
 
-    change = presubmit.Change('mychange', '', self.fake_root_dir, files, 0, 0)
+    change = presubmit.Change(
+        'mychange', '', self.fake_root_dir, files, 0, 0, None)
     affected_files = change.AffectedFiles(include_dirs=True)
     # Local paths should remain the same
     self.assertEquals(affected_files[0].LocalPath(), normpath('isdir'))
     self.assertEquals(affected_files[1].LocalPath(), normpath('isdir/blat.cc'))
     # Absolute paths should be prefixed
     self.assertEquals(affected_files[0].AbsoluteLocalPath(),
                       normpath(join(self.fake_root_dir, 'isdir')))
     self.assertEquals(affected_files[1].AbsoluteLocalPath(),
                       normpath(join(self.fake_root_dir, 'isdir/blat.cc')))
 
     # New helper functions need to work
     paths_from_change = change.AbsoluteLocalPaths(include_dirs=True)
     self.assertEqual(len(paths_from_change), 3)
     presubmit_path = join(self.fake_root_dir, 'isdir', 'PRESUBMIT.py')
     api = presubmit.InputApi(
         change=change, presubmit_path=presubmit_path,
         is_committing=True, tbr=False, rietveld=None, verbose=False)
     paths_from_api = api.AbsoluteLocalPaths(include_dirs=True)
     self.assertEqual(len(paths_from_api), 2)
     for absolute_paths in [paths_from_change, paths_from_api]:
       self.assertEqual(absolute_paths[0],
                        normpath(join(self.fake_root_dir, 'isdir')))
       self.assertEqual(absolute_paths[1],
                        normpath(join(self.fake_root_dir, 'isdir', 'blat.cc')))
 
   def testDeprecated(self):
     presubmit.warn(mox.IgnoreArg(), category=mox.IgnoreArg(), stacklevel=2)
     self.mox.ReplayAll()
 
-    change = presubmit.Change('mychange', '', self.fake_root_dir, [], 0, 0)
+    change = presubmit.Change(
+        'mychange', '', self.fake_root_dir, [], 0, 0, None)
     api = presubmit.InputApi(
         change,
         presubmit.os.path.join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'), True,
         False, None, False)
     api.AffectedTextFiles(include_deletes=False)
 
   def testReadFileStringDenied(self):
     self.mox.ReplayAll()
 
-    change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
-                              0, 0)
+    change = presubmit.Change(
+        'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, None)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
         False, None, False)
     self.assertRaises(IOError, input_api.ReadFile, 'boo', 'x')
 
   def testReadFileStringAccepted(self):
     path = presubmit.os.path.join(self.fake_root_dir, 'AA/boo')
     presubmit.gclient_utils.FileRead(path, 'x').AndReturn(None)
     self.mox.ReplayAll()
 
-    change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
-                              0, 0)
+    change = presubmit.Change(
+        'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, None)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
         False, None, False)
     input_api.ReadFile(path, 'x')
 
   def testReadFileAffectedFileDenied(self):
     fileobj = presubmit.AffectedFile('boo', 'M', 'Unrelated')
     self.mox.ReplayAll()
 
-    change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
-                              0, 0)
+    change = presubmit.Change(
+        'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, None)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
         False, None, False)
     self.assertRaises(IOError, input_api.ReadFile, fileobj, 'x')
 
   def testReadFileAffectedFileAccepted(self):
     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)
+    change = presubmit.Change(
+        'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, None)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
         False, None, False)
     input_api.ReadFile(fileobj, 'x')
 
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
@@ skipping 131 matching lines @@
     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(), files)
     self.failUnless(len(output) == 1)
     self.failUnless(files[0] == output[0])
 
 
-class GclChangeUnittest(PresubmitTestsBase):
+class ChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     members = [
         'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
         'DescriptionText', 'FullDescriptionText', 'LocalPaths', 'Name',
         'RepositoryRoot', 'RightHandSideLines', 'ServerPaths',
-        'issue', 'patchset', 'scm', 'tags',
+        'author_email', 'issue', 'patchset', 'scm', 'tags',
     ]
     # If this test fails, you should add the relevant test.
     self.mox.ReplayAll()
 
-    change = presubmit.Change('foo', 'foo', self.fake_root_dir, [('M', 'AA')],
-                              0, 0)
+    change = presubmit.Change(
+        'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, 'foo')
     self.compareMembers(change, members)
 
+  def testMembers(self):
+    change = presubmit.Change(
+        'foo1', 'foo2\nDRU=ro', self.fake_root_dir, [('Y', 'AA')], 3, 5, 'foo3')
+    self.assertEquals('foo1', change.Name())
+    self.assertEquals('foo2', change.DescriptionText())
+    self.assertEquals('foo3', change.author_email)
+    self.assertEquals('ro', change.DRU)
+    self.assertEquals(3, change.issue)
+    self.assertEquals(5, change.patchset)
+    self.assertEquals(self.fake_root_dir, change.RepositoryRoot())
+    self.assertEquals(1, len(change.AffectedFiles(include_dirs=True)))
+    self.assertEquals('Y', change.AffectedFiles(include_dirs=True)[0].Action())
+
 
 class CannedChecksUnittest(PresubmitTestsBase):
   """Tests presubmit_canned_checks.py."""
 
   def setUp(self):
     PresubmitTestsBase.setUp(self)
 
   def MockInputApi(self, change, committing):
     input_api = self.mox.CreateMock(presubmit.InputApi)
     input_api.cStringIO = presubmit.cStringIO
@@ skipping 40 matching lines @@
       'CheckSvnModifiedDirectories',
       'CheckSvnForCommonMimeTypes', 'CheckSvnProperty',
       'RunPythonUnitTests', 'RunPylint',
       'RunUnitTests', 'RunUnitTestsInDirectory',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit_canned_checks, members)
 
   def DescriptionTest(self, check, description1, description2, error_type,
                       committing):
-    change1 = presubmit.Change('foo1', description1, self.fake_root_dir, None,
-                               0, 0)
+    change1 = presubmit.Change(
+        'foo1', description1, self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, committing)
-    change2 = presubmit.Change('foo2', description2, self.fake_root_dir, None,
-                               0, 0)
+    change2 = presubmit.Change(
+        'foo2', description2, self.fake_root_dir, None, 0, 0, None)
     input_api2 = self.MockInputApi(change2, committing)
     self.mox.ReplayAll()
 
     results1 = check(input_api1, presubmit.OutputApi)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
   def ContentTest(self, check, content1, content2, error_type):
-    change1 = presubmit.Change('foo1', 'foo1\n', self.fake_root_dir, None,
-                               0, 0)
+    change1 = presubmit.Change(
+        'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file.LocalPath().AndReturn('foo.cc')
     # Format is (file, line number, line content)
     output1 = [
       (affected_file, 42, 'yo, ' + content1),
       (affected_file, 43, 'yer'),
       (affected_file, 23, 'ya'),
     ]
     input_api1.RightHandSideLines(mox.IgnoreArg()).AndReturn(output1)
-    change2 = presubmit.Change('foo2', 'foo2\n', self.fake_root_dir, None,
-                               0, 0)
+    change2 = presubmit.Change(
+        'foo2', 'foo2\n', self.fake_root_dir, None, 0, 0, None)
     input_api2 = self.MockInputApi(change2, False)
     output2 = [
       (affected_file, 42, 'yo, ' + content2),
       (affected_file, 43, 'yer'),
       (affected_file, 23, 'ya'),
     ]
     input_api2.RightHandSideLines(mox.IgnoreArg()).AndReturn(output2)
     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 ReadFileTest(self, check, content1, content2, error_type):
     self.mox.StubOutWithMock(presubmit.InputApi, 'ReadFile')
-    change1 = presubmit.Change('foo1', 'foo1\n', self.fake_root_dir, None,
-                               0, 0)
+    change1 = presubmit.Change(
+        'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
     affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api1.AffectedSourceFiles(None).AndReturn([affected_file1])
     input_api1.ReadFile(affected_file1, 'rb').AndReturn(content1)
-    change2 = presubmit.Change('foo2', 'foo2\n', self.fake_root_dir, None,
-                               0, 0)
+    change2 = presubmit.Change(
+        'foo2', 'foo2\n', self.fake_root_dir, None, 0, 0, None)
     input_api2 = self.MockInputApi(change2, False)
     affected_file2 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api2.AffectedSourceFiles(None).AndReturn([affected_file2])
     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_name, value1, value2, committing,
                       error_type, use_source_file):
-    change1 = presubmit.SvnChange('mychange', '', self.fake_root_dir, [], 0, 0)
+    change1 = presubmit.SvnChange(
+        'mychange', '', self.fake_root_dir, [], 0, 0, None)
     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_name).AndReturn(value1)
     presubmit.scm.SVN.GetFileProperty(presubmit.normpath('foo.cc'),
                                       property_name).AndReturn(value1)
-    change2 = presubmit.SvnChange('mychange', '', self.fake_root_dir, [], 0, 0)
+    change2 = presubmit.SvnChange(
+        'mychange', '', self.fake_root_dir, [], 0, 0, None)
     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)
 
@@ skipping 88 matching lines @@
     self.ContentTest(presubmit_canned_checks.CheckChangeTodoHasOwner,
                      "TODO(foo): bar", "TODO: bar",
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckChangeHasNoTabs(self):
     self.ContentTest(presubmit_canned_checks.CheckChangeHasNoTabs,
                      'blah blah', 'blah\tblah',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
     # Make sure makefiles are ignored.
-    change1 = presubmit.Change('foo1', 'foo1\n', self.fake_root_dir, None,
-                               0, 0)
+    change1 = presubmit.Change(
+        'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
     affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file1.LocalPath().AndReturn('foo.cc')
     affected_file2 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file2.LocalPath().AndReturn('foo/Makefile')
     affected_file3 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file3.LocalPath().AndReturn('makefile')
     # Only this one will trigger.
     affected_file4 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file4.LocalPath().AndReturn('makefile.foo')
@@ skipping 497 matching lines @@
   def testCannedCheckOwners_WithoutOwnerLGTM(self):
     self.AssertOwnersWorks(uncovered_files=set(['foo.cc']),
         expected_output='Missing LGTM from an OWNER for: foo.cc\n')
 
   def testCannedCheckOwners_WithLGTMs(self):
     self.AssertOwnersWorks(approvers=set(['ben@example.com']),
                            uncovered_files=set())
 
   def testCannedRunUnitTests(self):
     change = presubmit.Change(
-        'foo1', 'description1', self.fake_root_dir, None, 0, 0)
+        'foo1', 'description1', self.fake_root_dir, None, 0, 0, None)
     input_api = self.MockInputApi(change, False)
     input_api.verbose = True
     unit_tests = ['allo', 'bar.py']
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.subprocess.check_call(
         ['allo', '--verbose'], cwd=self.fake_root_dir)
     cmd = ['bar.py', '--verbose']
     if input_api.platform == 'win32':
       cmd.insert(0, input_api.python_executable)
     input_api.subprocess.check_call(
         cmd, cwd=self.fake_root_dir).AndRaise(
             input_api.subprocess.CalledProcessError())
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunUnitTests(
         input_api,
         presubmit.OutputApi,
         unit_tests)
     self.assertEqual(1, len(results))
     self.assertEqual(
         presubmit.OutputApi.PresubmitPromptWarning, results[0].__class__)
     self.checkstdout('Running allo\nRunning bar.py\n')
 
   def testCannedRunUnitTestsInDirectory(self):
     change = presubmit.Change(
-        'foo1', 'description1', self.fake_root_dir, None, 0, 0)
+        'foo1', 'description1', self.fake_root_dir, None, 0, 0, None)
     input_api = self.MockInputApi(change, False)
     input_api.verbose = True
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     path = presubmit.os.path.join(self.fake_root_dir, 'random_directory')
     input_api.os_listdir(path).AndReturn(['.', '..', 'a', 'b', 'c'])
     input_api.os_path.isfile = lambda x: not x.endswith('.')
     input_api.subprocess.check_call(
         [presubmit.os.path.join('random_directory', 'b'), '--verbose'],
         cwd=self.fake_root_dir)
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.RunUnitTestsInDirectory(
         input_api,
         presubmit.OutputApi,
         'random_directory',
         whitelist=['^a$', '^b$'],
         blacklist=['a'])
     self.assertEqual(results, [])
     self.checkstdout(
         'Running %s\n' % presubmit.os.path.join('random_directory', 'b'))
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()