A step closer to make presubmit SCM independent.

tests/presubmit_unittest.py

 #!/usr/bin/python
 # Copyright (c) 2006-2009 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."""
 
 import exceptions
 import StringIO
 import unittest
@@ skipping 34 matching lines @@
     presubmit.os.sep = os_sep
     presubmit.os.path.join = os_path_join
     presubmit.os.path.dirname = os_path_dirname
     presubmit.os.path.normpath = os_path_normpath
     presubmit.os.path.splitext = os_path_splitext
     self.mox.StubOutWithMock(presubmit, 'sys')
     # Special mocks.
     def MockAbsPath(f):
       return f
     presubmit.os.path.abspath = MockAbsPath
-    self.mox.StubOutWithMock(presubmit.gcl, 'GetRepositoryRoot')
-    fake_root_dir = self.RootDir()
-    self.fake_root_dir = fake_root_dir
-    def MockGetRepositoryRoot():
-      return fake_root_dir
-    presubmit.gcl.GetRepositoryRoot = MockGetRepositoryRoot
+    self.fake_root_dir = self.RootDir()
     self.mox.StubOutWithMock(presubmit.gclient, 'CaptureSVNInfo')
     self.mox.StubOutWithMock(presubmit.gcl, 'GetSVNFileProperty')
     self.mox.StubOutWithMock(presubmit.gcl, 'ReadFile')
+    self.mox.StubOutWithMock(presubmit.gcl, 'ChangeInfo')
 
-  def MakeBasicChange(self, name, description, root=None):
-    ci = presubmit.gcl.ChangeInfo(name, 0, 0, description, None)
-    if root is None:
-      root = self.fake_root_dir
-    return presubmit.GclChange(ci, root)
+  def MakeChangeInfo(self, name, issue, patchset, description):
+    ci = self.mox.CreateMock(presubmit.gcl.ChangeInfo)
+    ci.name = name
+    ci.issue = issue
+    ci.patchset = patchset
+    ci.description = description
+    ci.patch = None
+    ci.local_root = self.fake_root_dir
+    return ci
 
 
 class PresubmitUnittest(PresubmitTestsBase):
   """General presubmit_support.py tests (excluding InputApi and OutputApi)."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AffectedFile', 'DoPresubmitChecks', 'GclChange', 'InputApi',
       'ListRelevantPresubmitFiles', 'Main', 'NotImplementedException',
-      'OutputApi', 'ParseFiles', 'PresubmitExecuter',
-      'ScanSubDirs', 'SvnAffectedFile',
+      'OutputApi', 'ParseFiles', 'PresubmitExecuter', 'ScanSubDirs',
+      'SvnAffectedFile',
       'cPickle', 'cStringIO', 'exceptions',
       'fnmatch', 'gcl', 'gclient', 'glob', 'logging', 'marshal', 'normpath',
       'optparse',
       'os', 'pickle', 'presubmit_canned_checks', 're', 'subprocess', 'sys',
       'tempfile', 'traceback', 'types', 'unittest', 'urllib2', 'warnings',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
   def testListRelevantPresubmitFiles(self):
@@ skipping 44 matching lines @@
                          'BUG=123',
                          ' 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('foo', 'blat.cc')
-    notfound = presubmit.os.path.join('flop', 'notfound.txt')
-    flap = presubmit.os.path.join('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')
+    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.dll').AndReturn(True)
-    presubmit.os.path.isdir('binary.dll').AndReturn(False)
-    presubmit.os.path.exists('isdir').AndReturn(True)
-    presubmit.os.path.isdir('isdir').AndReturn(True)
+    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)
     presubmit.os.path.isdir(notfound).AndReturn(False)
     presubmit.os.path.exists(flap).AndReturn(False)
     presubmit.gclient.CaptureSVNInfo(flap
         ).AndReturn({'Node Kind': 'file'})
     presubmit.gcl.GetSVNFileProperty(blat, 'svn:mime-type').AndReturn(None)
     presubmit.gcl.GetSVNFileProperty(
-        'binary.dll', 'svn:mime-type').AndReturn('application/octet-stream')
+        binary, 'svn:mime-type').AndReturn('application/octet-stream')
     presubmit.gcl.GetSVNFileProperty(
         notfound, 'svn:mime-type').AndReturn('')
     presubmit.gclient.CaptureSVNInfo(blat).AndReturn(
             {'URL': 'svn:/foo/foo/blat.cc'})
-    presubmit.gclient.CaptureSVNInfo('binary.dll').AndReturn(
+    presubmit.gclient.CaptureSVNInfo(binary).AndReturn(
         {'URL': 'svn:/foo/binary.dll'})
     presubmit.gclient.CaptureSVNInfo(notfound).AndReturn({})
     presubmit.gclient.CaptureSVNInfo(flap).AndReturn(
             {'URL': 'svn:/foo/boo/flap.h'})
     presubmit.gcl.ReadFile(blat).AndReturn('boo!\nahh?')
     presubmit.gcl.ReadFile(notfound).AndReturn('look!\nthere?')
+    ci = self.MakeChangeInfo('mychange', 0, 0, '\n'.join(description_lines))
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='\n'.join(description_lines),
-                                  files=files)
     change = presubmit.GclChange(ci)
 
     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/')
@@ skipping 43 matching lines @@
     self.assertEquals(rhs_lines[3][2], 'there?')
 
   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')
+    ci = self.MakeChangeInfo('mychange', 0, 0, '\n'.join(description_lines))
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='\n'.join(description_lines),
-                                  files=files)
-
     executer = presubmit.PresubmitExecuter(ci, 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(ci, True)
@@ skipping 43 matching lines @@
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     haspresubmit_path = join(self.fake_root_dir, 'haspresubmit', 'PRESUBMIT.py')
     root_path = join(self.fake_root_dir, 'PRESUBMIT.py')
     presubmit.os.path.isfile(root_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
     presubmit.gcl.ReadFile(root_path,
                            'rU').AndReturn(self.presubmit_text)
     presubmit.gcl.ReadFile(haspresubmit_path,
                            'rU').AndReturn(self.presubmit_text)
+    ci = self.MakeChangeInfo('mychange', 0, 0, '\n'.join(description_lines))
+    ci.GetFileNames().AndReturn([item[1] for item in files])
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='\n'.join(description_lines),
-                                  files=files)
-
     output = StringIO.StringIO()
     input = StringIO.StringIO('y\n')
 
     self.failIf(presubmit.DoPresubmitChecks(ci, False, True, output, input,
                                             None, False))
     self.assertEqual(output.getvalue().count('!!'), 2)
 
   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')
+    ci = self.MakeChangeInfo('mychange', 0, 0, '\n'.join(description_lines))
     for i in range(2):
       presubmit.os.path.isfile(presubmit_path).AndReturn(True)
       presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
       presubmit.gcl.ReadFile(presubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
       presubmit.gcl.ReadFile(haspresubmit_path, 'rU'
           ).AndReturn(self.presubmit_text)
+      ci.GetFileNames().AndReturn([item[1] for item in files])
+      ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+      ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='\n'.join(description_lines),
-                                  files=files)
-
     output = StringIO.StringIO()
     input = StringIO.StringIO('n\n')  # say no to the warning
     self.failIf(presubmit.DoPresubmitChecks(ci, False, True, output, input,
                                             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(ci,
-                                                False,
-                                                True,
-                                                output,
-                                                input,
-                                                None,
-                                                True))
+    self.failUnless(presubmit.DoPresubmitChecks(ci, False, True, output, input,
+                                                None, True))
     self.assertEquals(output.getvalue().count('??'), 2)
 
   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')
     presubmit.os.path.isfile(presubmit_path).AndReturn(True)
     presubmit.os.path.isfile(haspresubmit_path).AndReturn(True)
     presubmit.gcl.ReadFile(presubmit_path, 'rU').AndReturn(self.presubmit_text)
-    presubmit.gcl.ReadFile(haspresubmit_path, 'rU'
-        ).AndReturn(self.presubmit_text)
+    presubmit.gcl.ReadFile(haspresubmit_path, 'rU').AndReturn(
+        self.presubmit_text)
+    ci = self.MakeChangeInfo('mychange', 0, 0, '\n'.join(description_lines))
+    ci.GetFileNames().AndReturn([item[1] for item in files])
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='\n'.join(description_lines),
-                                  files=files)
     output = StringIO.StringIO()
     input = StringIO.StringIO()  # should be unused
     self.failIf(presubmit.DoPresubmitChecks(ci, False, True, output, input,
                                             None, False))
     self.assertEqual(output.getvalue().count('??'), 2)
     self.assertEqual(output.getvalue().count('XX!!XX'), 2)
     self.assertEqual(output.getvalue().count('(y/N)'), 0)
 
   def testDoDefaultPresubmitChecks(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'STORY=http://tracker/123')
     files = [
       ['A', join('haspresubmit', 'blat.cc')],
     ]
     DEFAULT_SCRIPT = """
 def CheckChangeOnUpload(input_api, output_api):
   return [output_api.PresubmitError("!!")]
 def CheckChangeOnCommit(input_api, output_api):
   raise Exception("Test error")
 """
     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)
+    ci = self.MakeChangeInfo('mychange', 0, 0, '\n'.join(description_lines))
+    ci.GetFileNames().AndReturn([item[1] for item in files])
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
-
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='\n'.join(description_lines),
-                                  files=files)
-
     
     output = StringIO.StringIO()
     input = StringIO.StringIO('y\n')
     # Always fail.
     self.failIf(presubmit.DoPresubmitChecks(ci, False, True, output, input,
                                             DEFAULT_SCRIPT, False))
     self.assertEquals(output.getvalue().count('!!'), 1)
 
   def testDirectoryHandling(self):
     files = [
       ['A', 'isdir'],
       ['A', 'isdir\\blat.cc'],
     ]
-    presubmit.os.path.exists('isdir').AndReturn(True)
-    presubmit.os.path.isdir('isdir').AndReturn(True)
-    presubmit.os.path.exists(presubmit.os.path.join('isdir', 'blat.cc')
-        ).AndReturn(True)
-    presubmit.os.path.isdir(presubmit.os.path.join('isdir', 'blat.cc')
-        ).AndReturn(False)
+    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)
+    ci = self.MakeChangeInfo('mychange', 0, 0, 'foo')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='foo', files=files)
+
     change = presubmit.GclChange(ci)
-
     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 17 matching lines @@
     return [output_api.PresubmitError('Tag parsing failed. 4 ' + 
                                       input_api.change.DescriptionText())]
   if (input_api.change.FullDescriptionText() !=
       'Blah Blah\\n\\nSTORY=http://tracker.com/42\\nBUG=boo\\n'):
     return [output_api.PresubmitError('Tag parsing failed. 5 ' +
                                       input_api.change.FullDescriptionText())]
   return [output_api.PresubmitNotifyResult(input_api.change.tags['STORY'])]
 def CheckChangeOnCommit(input_api, output_api):
   raise Exception("Test error")
 """
+    ci = self.MakeChangeInfo(
+        'foo', 0, 0, "Blah Blah\n\nSTORY=http://tracker.com/42\nBUG=boo\n")
+    ci.GetFileNames().AndReturn([])
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn([])
     self.mox.ReplayAll()
 
-    change = presubmit.gcl.ChangeInfo(
-        name='foo',
-        issue=0,
-        patchset=0,
-        description="Blah Blah\n\nSTORY=http://tracker.com/42\nBUG=boo\n",
-        files=None)
     output = StringIO.StringIO()
     input = StringIO.StringIO('y\n')
-    self.failUnless(presubmit.DoPresubmitChecks(change, False, True, output,
+    self.failUnless(presubmit.DoPresubmitChecks(ci, False, True, output,
                                                 input, 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'))
 
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
@@ skipping 46 matching lines @@
     self.assertEquals(api.PresubmitLocalPath(), 'foo/path')
     self.assertEquals(api.change, 42)
 
   def testInputApiPresubmitScriptFiltering(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'BUG=123',
                          ' STORY =http://foo/  \t',
                          'and some more regular text')
-    blat = join('foo', 'blat.cc')
-    readme = join('foo', 'blat', 'READ_ME2')
-    binary = join('foo', 'blat', 'binary.dll')
-    weird = join('foo', 'blat', 'weird.xyz')
-    third_party = join('foo', 'third_party', 'third.cc')
-    another = join('foo', 'blat', 'another.h')
-    beingdeleted = join('foo', 'mat', 'beingdeleted.txt')
-    notfound = join('flop', 'notfound.txt')
-    flap = join('boo', 'flap.h')
     files = [
-      ['A', blat],
-      ['M', readme],
-      ['M', binary],
-      ['M', weird],
-      ['M', another],
-      ['M', third_party],
+      ['A', join('foo', 'blat.cc')],
+      ['M', join('foo', 'blat', 'READ_ME2')],
+      ['M', join('foo', 'blat', 'binary.dll')],
+      ['M', join('foo', 'blat', 'weird.xyz')],
+      ['M', join('foo', 'blat', 'another.h')],
+      ['M', join('foo', 'third_party', 'third.cc')],
       ['D', 'foo/mat/beingdeleted.txt'],
       ['M', 'flop/notfound.txt'],
       ['A', 'boo/flap.h'],
     ]
-
+    blat = presubmit.normpath(join(self.fake_root_dir, files[0][1]))
+    readme = presubmit.normpath(join(self.fake_root_dir, files[1][1]))
+    binary = presubmit.normpath(join(self.fake_root_dir, files[2][1]))
+    weird = presubmit.normpath(join(self.fake_root_dir, files[3][1]))
+    another = presubmit.normpath(join(self.fake_root_dir, files[4][1]))
+    third_party = presubmit.normpath(join(self.fake_root_dir, files[5][1]))
+    beingdeleted = presubmit.normpath(join(self.fake_root_dir, files[6][1]))
+    notfound = presubmit.normpath(join(self.fake_root_dir, files[7][1]))
+    flap = presubmit.normpath(join(self.fake_root_dir, files[8][1]))
     for i in (blat, readme, binary, weird, another, third_party):
       presubmit.os.path.exists(i).AndReturn(True)
       presubmit.os.path.isdir(i).AndReturn(False)
     presubmit.os.path.exists(beingdeleted).AndReturn(False)
     presubmit.os.path.exists(notfound).AndReturn(False)
     presubmit.os.path.exists(flap).AndReturn(True)
     presubmit.os.path.isdir(flap).AndReturn(False)
     presubmit.gclient.CaptureSVNInfo(beingdeleted).AndReturn({})
     presubmit.gclient.CaptureSVNInfo(notfound).AndReturn({})
     presubmit.gcl.GetSVNFileProperty(blat, 'svn:mime-type').AndReturn(None)
     presubmit.gcl.GetSVNFileProperty(readme, 'svn:mime-type').AndReturn(None)
     presubmit.gcl.GetSVNFileProperty(binary, 'svn:mime-type').AndReturn(
         'application/octet-stream')
     presubmit.gcl.GetSVNFileProperty(weird, 'svn:mime-type').AndReturn(None)
     presubmit.gcl.GetSVNFileProperty(another, 'svn:mime-type').AndReturn(None)
     presubmit.gcl.GetSVNFileProperty(third_party, 'svn:mime-type'
         ).AndReturn(None)
     presubmit.gcl.ReadFile(blat).AndReturn('whatever\ncookie')
     presubmit.gcl.ReadFile(another).AndReturn('whatever\ncookie2')
+    ci = self.MakeChangeInfo('mychange', 0, 0, '\n'.join(description_lines))
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='\n'.join(description_lines),
-                                  files=files)
     change = presubmit.GclChange(ci)
-    input_api = presubmit.InputApi(change, 'foo/PRESUBMIT.py', False)
+    input_api = presubmit.InputApi(change,
+                                   join(self.fake_root_dir, 'foo',
+                                        'PRESUBMIT.py'),
+                                   False)
     # Doesn't filter much
     got_files = input_api.AffectedFiles()
     self.assertEquals(len(got_files), 7)
-    self.assertEquals(got_files[0].LocalPath(), presubmit.normpath(blat))
-    self.assertEquals(got_files[1].LocalPath(), presubmit.normpath(readme))
-    self.assertEquals(got_files[2].LocalPath(), presubmit.normpath(binary))
-    self.assertEquals(got_files[3].LocalPath(), presubmit.normpath(weird))
-    self.assertEquals(got_files[4].LocalPath(), presubmit.normpath(another))
-    self.assertEquals(got_files[5].LocalPath(), presubmit.normpath(third_party))
-    self.assertEquals(got_files[6].LocalPath(),
-                      presubmit.normpath(beingdeleted))
+    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]))
+    self.assertEquals(got_files[3].LocalPath(), presubmit.normpath(files[3][1]))
+    self.assertEquals(got_files[4].LocalPath(), presubmit.normpath(files[4][1]))
+    self.assertEquals(got_files[5].LocalPath(), presubmit.normpath(files[5][1]))
+    self.assertEquals(got_files[6].LocalPath(), presubmit.normpath(files[6][1]))
     # Ignores weird because of whitelist, third_party because of blacklist,
     # binary isn't a text file and beingdeleted doesn't exist. The rest is
     # outside foo/.
     rhs_lines = [x for x in input_api.RightHandSideLines(None)]
     self.assertEquals(len(rhs_lines), 4)
-    self.assertEqual(rhs_lines[0][0].LocalPath(), presubmit.normpath(blat))
-    self.assertEqual(rhs_lines[1][0].LocalPath(), presubmit.normpath(blat))
-    self.assertEqual(rhs_lines[2][0].LocalPath(), presubmit.normpath(another))
-    self.assertEqual(rhs_lines[3][0].LocalPath(), presubmit.normpath(another))
+    self.assertEqual(rhs_lines[0][0].LocalPath(),
+                     presubmit.normpath(files[0][1]))
+    self.assertEqual(rhs_lines[1][0].LocalPath(),
+                     presubmit.normpath(files[0][1]))
+    self.assertEqual(rhs_lines[2][0].LocalPath(),
+                     presubmit.normpath(files[4][1]))
+    self.assertEqual(rhs_lines[3][0].LocalPath(),
+                     presubmit.normpath(files[4][1]))
 
   def testDefaultWhiteListBlackListFilters(self):
     def f(x):
       return presubmit.AffectedFile(x, 'M')
     files = [
       (
         [
           # To be tested.
           f('a/experimental/b'),
           f('experimental/b'),
@@ skipping 57 matching lines @@
         self.assertEquals(results[i].LocalPath(),
                           presubmit.normpath(item[1][i]))
       # Same number of expected results.
       self.assertEquals(len(results), len(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:
+      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.gcl.GetSVNFileProperty(item, 'svn:mime-type').AndReturn(None)
+    ci = self.MakeChangeInfo('mychange', 0, 0, '')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo('mychange', 0, 0, '', files)
     change = presubmit.GclChange(ci)
-    input_api = presubmit.InputApi(change, './PRESUBMIT.py', False)
+    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:
+      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.gcl.GetSVNFileProperty(item, 'svn:mime-type').AndReturn(None)
+    ci = self.MakeChangeInfo('mychange', 0, 0, '')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo('mychange', 0, 0, '', files)
     change = presubmit.GclChange(ci)
     input_api = presubmit.InputApi(change, './PRESUBMIT.py', 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')],
     ]
+    ci = self.MakeChangeInfo('mychange', 0, 0, '')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn(files)
     self.mox.ReplayAll()
 
-    ci = presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                  description='', files=files)
     # It doesn't make sense on non-Windows platform. This is somewhat hacky,
     # but it is needed since we can't just use os.path.join('c:', 'temp').
-    change = presubmit.GclChange(ci, self.fake_root_dir)
+    change = presubmit.GclChange(ci)
     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)
     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.warnings.warn(mox.IgnoreArg(), category=mox.IgnoreArg(),
                             stacklevel=2)
+    ci = self.MakeChangeInfo('mychange', 0, 0, 'Bleh\n')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn([])
     self.mox.ReplayAll()
-    change = presubmit.GclChange(
-        presubmit.gcl.ChangeInfo(name='mychange', issue=0, patchset=0,
-                                 description='Bleh\n', files=None))
-    api = presubmit.InputApi(change, 'foo/PRESUBMIT.py', True)
+
+    change = presubmit.GclChange(ci)
+    api = presubmit.InputApi(
+        change,
+        presubmit.os.path.join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'), True)
     api.AffectedTextFiles(include_deletes=False)
 
   def testReadFileStringDenied(self):
+    ci = self.MakeChangeInfo('foo', 0, 0, 'Foo\n')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn([('M', 'AA')])
     self.mox.ReplayAll()
-    input_api = presubmit.InputApi(None, './p', False)
-    input_api.change = self.MakeBasicChange('foo', 'Foo\n', '/AA')
+
+    input_api = presubmit.InputApi(
+        None, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
+    input_api.change = presubmit.GclChange(ci)
     self.assertRaises(IOError, input_api.ReadFile, 'boo', 'x')
 
   def testReadFileStringAccepted(self):
-    presubmit.gcl.ReadFile('/AA/boo', 'x').AndReturn(None)
+    ci = self.MakeChangeInfo('foo', 0, 0, 'Foo\n')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    path = presubmit.os.path.join(self.fake_root_dir, 'AA/boo')
+    ci.GetFiles().AndReturn([('M', 'AA')])
+    presubmit.gcl.ReadFile(path, 'x').AndReturn(None)
     self.mox.ReplayAll()
-    input_api = presubmit.InputApi(None, './p', False)
-    input_api.change = self.MakeBasicChange('foo', 'Foo\n', '/AA')
-    input_api.ReadFile('/AA/boo', 'x')
+
+    input_api = presubmit.InputApi(
+        None, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
+    input_api.change = presubmit.GclChange(ci)
+    input_api.ReadFile(path, 'x')
 
   def testReadFileAffectedFileDenied(self):
-    file = presubmit.AffectedFile('boo', 'M')
+    ci = self.MakeChangeInfo('foo', 0, 0, 'Foo\n')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn([('M', 'AA')])
+    file = presubmit.AffectedFile('boo', 'M', 'Unrelated')
     self.mox.ReplayAll()
-    input_api = presubmit.InputApi(None, './p', False)
-    input_api.change = self.MakeBasicChange('foo', 'Foo\n', '/AA')
-    self.assertRaises(IOError, input_api.ReadFile, 'boo', 'x')
+
+    input_api = presubmit.InputApi(
+        None, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
+    input_api.change = presubmit.GclChange(ci)
+    self.assertRaises(IOError, input_api.ReadFile, file, 'x')
 
   def testReadFileAffectedFileAccepted(self):
-    file = presubmit.AffectedFile('/AA/boo', 'M')
-    presubmit.gcl.ReadFile('/AA/boo', 'x').AndReturn(None)
+    ci = self.MakeChangeInfo('foo', 0, 0, 'Foo\n')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn([('M', 'AA')])
+    file = presubmit.AffectedFile('AA/boo', 'M', self.fake_root_dir)
+    presubmit.gcl.ReadFile(file.AbsoluteLocalPath(), 'x').AndReturn(None)
     self.mox.ReplayAll()
-    input_api = presubmit.InputApi(None, './p', False)
-    input_api.change = self.MakeBasicChange('foo', 'Foo\n', '/AA')
-    input_api.ReadFile('/AA/boo', 'x')
+
+    input_api = presubmit.InputApi(
+        None, presubmit.os.path.join(self.fake_root_dir, '/p'), False)
+    input_api.change = presubmit.GclChange(ci)
+    input_api.ReadFile(file, 'x')
 
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'MailTextResult', 'PresubmitError', 'PresubmitNotifyResult',
       'PresubmitPromptWarning', 'PresubmitResult',
     ]
@@ skipping 118 matching lines @@
         ).AndReturn('application/octet-stream')
     self.mox.ReplayAll()
 
     output = filter(lambda x: x.IsTextFile(), list)
     self.failUnless(len(output) == 1)
     self.failUnless(list[0] == output[0])
 
 
 class GclChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
-    self.mox.ReplayAll()
     members = [
         'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
         'DescriptionText', 'FullDescriptionText', 'LocalPaths', 'Name',
         'RepositoryRoot', 'RightHandSideLines', 'ServerPaths',
         'issue', 'patchset', 'tags',
     ]
     # If this test fails, you should add the relevant test.
-    ci = presubmit.gcl.ChangeInfo('', 0, 0, '', None)
-    self.compareMembers(presubmit.GclChange(ci, self.fake_root_dir), members)
+    ci = self.MakeChangeInfo('', 0, 0, '')
+    ci.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci.GetFiles().AndReturn([])
+    self.mox.ReplayAll()
+
+    self.compareMembers(presubmit.GclChange(ci), members)
 
 
 class CannedChecksUnittest(PresubmitTestsBase):
   """Tests presubmit_canned_checks.py."""
 
   def setUp(self):
     PresubmitTestsBase.setUp(self)
     self.mox.StubOutWithMock(presubmit_canned_checks,
                          '_RunPythonUnitTests_LoadTests')
 
@@ skipping 19 matching lines @@
       'CheckDoNotSubmitInDescription', 'CheckDoNotSubmitInFiles',
       'CheckLongLines', 'CheckTreeIsOpen', 'RunPythonUnitTests',
     ]
     # 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):
     input_api1 = self.MockInputApi()
     input_api1.is_committing = committing
-    input_api1.change = self.MakeBasicChange('foo', description1)
+    ci1 = self.MakeChangeInfo('foo', 0, 0, description1)
+    ci1.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci1.GetFiles().AndReturn([])
     input_api2 = self.MockInputApi()
     input_api2.is_committing = committing
-    input_api2.change = self.MakeBasicChange('foo', description2)
+    ci2 = self.MakeChangeInfo('foo', 0, 0, description2)
+    ci2.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci2.GetFiles().AndReturn([])
     self.mox.ReplayAll()
 
+    input_api1.change = presubmit.GclChange(ci1)
+    input_api2.change = presubmit.GclChange(ci2)
     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):
     input_api1 = self.MockInputApi()
-    input_api1.change = self.MakeBasicChange('foo', 'Foo\n')
+    ci1 = self.MakeChangeInfo('foo', 0, 0, 'foo1\n')
+    ci1.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci1.GetFiles().AndReturn([])
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file.LocalPath().AndReturn('foo.cc')
     output1 = [
       (affected_file, 42, 'yo, ' + content1),
       (affected_file, 43, 'yer'),
       (affected_file, 23, 'ya'),
     ]
     input_api1.RightHandSideLines(mox.IgnoreArg()).AndReturn(output1)
     input_api2 = self.MockInputApi()
-    input_api2.change = self.MakeBasicChange('foo', 'Foo\n')
+    ci2 = self.MakeChangeInfo('foo2', 0, 0, 'foo2\n')
+    ci2.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci2.GetFiles().AndReturn([])
     output2 = [
       (affected_file, 42, 'yo, ' + content2),
       (affected_file, 43, 'yer'),
       (affected_file, 23, 'ya'),
     ]
     input_api2.RightHandSideLines(mox.IgnoreArg()).AndReturn(output2)
     self.mox.ReplayAll()
 
+    input_api1.change = presubmit.GclChange(ci1)
+    input_api2.change = presubmit.GclChange(ci2)
     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):
     input_api1 = self.MockInputApi()
     self.mox.StubOutWithMock(input_api1, 'ReadFile')
-    input_api1.change = self.MakeBasicChange('foo', 'Foo\n')
+    ci1 = self.MakeChangeInfo('foo', 0, 0, 'foo1\n')
+    ci1.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci1.GetFiles().AndReturn([])
     affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api1.AffectedSourceFiles(None).AndReturn([affected_file1])
     input_api1.ReadFile(affected_file1, 'rb').AndReturn(content1)
     input_api2 = self.MockInputApi()
     self.mox.StubOutWithMock(input_api2, 'ReadFile')
-    input_api2.change = self.MakeBasicChange('foo', 'Foo\n')
+    ci2 = self.MakeChangeInfo('foo2', 0, 0, 'foo2\n')
+    ci2.GetLocalRoot().AndReturn(self.fake_root_dir)
+    ci2.GetFiles().AndReturn([])
     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()
 
+    input_api1.change = presubmit.GclChange(ci1)
+    input_api2.change = presubmit.GclChange(ci2)
     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,
                       error_type):
     input_api1 = self.MockInputApi()
     input_api1.is_committing = committing
@@ skipping 285 matching lines @@
     test_result.errors = 0
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 0)
 
 
 if __name__ == '__main__':
   unittest.main()