Get presubmit_support to compute diffs against a given upstream.

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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: disable=E1101,E1103
 
 import functools
@@ skipping 488 matching lines @@
              ('M      ', 'foo/TestExpectations')]
 
     for op, path in files:
       full_path = presubmit.os.path.join(self.fake_root_dir, *path.split('/'))
       if op.startswith('D'):
         os.path.exists(full_path).AndReturn(False)
       else:
         os.path.exists(full_path).AndReturn(False)
         os.path.isfile(full_path).AndReturn(True)
 
-    presubmit.scm.GIT.GenerateDiff(self.fake_root_dir, files=[], full_move=True
+    presubmit.scm.GIT.GenerateDiff(
+        self.fake_root_dir, files=[], full_move=True, branch=None
         ).AndReturn('\n'.join(unified_diff))
 
     self.mox.ReplayAll()
 
     change = presubmit.GitChange(
         'mychange',
         '\n'.join(description_lines),
         self.fake_root_dir,
         files,
         0,
         0,
-        None)
+        None,
+        upstream=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 803 matching lines @@
                      presubmit.normpath(files[0][1]))
     self.assertEqual(rhs_lines[3][0].LocalPath(),
                      presubmit.normpath(files[0][1]))
     self.assertEqual(rhs_lines[7][0].LocalPath(),
                      presubmit.normpath(files[4][1]))
     self.assertEqual(rhs_lines[13][0].LocalPath(),
                      presubmit.normpath(files[4][1]))
 
   def testDefaultWhiteListBlackListFilters(self):
     def f(x):
-      return presubmit.AffectedFile(x, 'M', self.fake_root_dir)
+      return presubmit.AffectedFile(x, 'M', self.fake_root_dir, None)
     files = [
       (
         [
           # To be tested.
           f('testing_support/google_appengine/b'),
           f('testing_support/not_google_appengine/foo.cc'),
         ],
         [
           # Expected.
           'testing_support/not_google_appengine/foo.cc',
@@ skipping 309 matching lines @@
 class AffectedFileUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPath', 'Action', 'ChangedContents', 'DIFF_CACHE',
       'GenerateScmDiff', 'IsDirectory', 'IsTextFile', 'LocalPath',
       'NewContents', 'Property', 'ServerPath',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(
-        presubmit.AffectedFile('a', 'b', self.fake_root_dir), members)
+        presubmit.AffectedFile('a', 'b', self.fake_root_dir, None), members)
     self.compareMembers(
-        presubmit.SvnAffectedFile('a', 'b', self.fake_root_dir), members)
+        presubmit.SvnAffectedFile('a', 'b', self.fake_root_dir, None), members)
     self.compareMembers(
-        presubmit.GitAffectedFile('a', 'b', self.fake_root_dir), members)
+        presubmit.GitAffectedFile('a', 'b', self.fake_root_dir, None), members)
 
   def testAffectedFile(self):
     path = presubmit.os.path.join('foo', 'blat.cc')
     f_path = presubmit.os.path.join(self.fake_root_dir, path)
     presubmit.os.path.exists(f_path).AndReturn(True)
     presubmit.os.path.isdir(f_path).AndReturn(False)
     presubmit.gclient_utils.FileRead(f_path, 'rU').AndReturn('whatever\ncookie')
     presubmit.scm.SVN._CaptureInfo([path], self.fake_root_dir).AndReturn(
         {'URL': 'svn:/foo/foo/blat.cc'})
     self.mox.ReplayAll()
-    af = presubmit.SvnAffectedFile('foo/blat.cc', 'M', self.fake_root_dir)
+    af = presubmit.SvnAffectedFile('foo/blat.cc', 'M', self.fake_root_dir, None)
     self.assertEquals('svn:/foo/foo/blat.cc', af.ServerPath())
     self.assertEquals(presubmit.normpath('foo/blat.cc'), af.LocalPath())
     self.assertEquals('M', af.Action())
     self.assertEquals(['whatever', 'cookie'], af.NewContents())
 
   def testAffectedFileNotExists(self):
     notfound = 'notfound.cc'
     f_notfound = presubmit.os.path.join(self.fake_root_dir, notfound)
     presubmit.os.path.exists(f_notfound).AndReturn(False)
     presubmit.gclient_utils.FileRead(f_notfound, 'rU').AndRaise(IOError)
     self.mox.ReplayAll()
-    af = presubmit.AffectedFile(notfound, 'A', self.fake_root_dir)
+    af = presubmit.AffectedFile(notfound, 'A', self.fake_root_dir, None)
     self.assertEquals('', af.ServerPath())
     self.assertEquals([], af.NewContents())
 
   def testProperty(self):
     presubmit.scm.SVN.GetFileProperty(
         'foo.cc', 'svn:secret-property', self.fake_root_dir
         ).AndReturn('secret-property-value')
     self.mox.ReplayAll()
-    affected_file = presubmit.SvnAffectedFile('foo.cc', 'A', self.fake_root_dir)
+    affected_file = presubmit.SvnAffectedFile('foo.cc', 'A', self.fake_root_dir,
+                                              None)
     # Verify cache coherency.
     self.assertEquals('secret-property-value',
                       affected_file.Property('svn:secret-property'))
     self.assertEquals('secret-property-value',
                       affected_file.Property('svn:secret-property'))
 
   def testIsDirectoryNotExists(self):
     filename = 'foo.cc'
     f_filename = presubmit.os.path.join(self.fake_root_dir, filename)
     presubmit.os.path.exists(f_filename).AndReturn(False)
     presubmit.scm.SVN._CaptureInfo([filename], self.fake_root_dir).AndReturn({})
     self.mox.ReplayAll()
-    affected_file = presubmit.SvnAffectedFile(filename, 'A', self.fake_root_dir)
+    affected_file = presubmit.SvnAffectedFile(filename, 'A', self.fake_root_dir,
+                                              None)
     # Verify cache coherency.
     self.failIf(affected_file.IsDirectory())
     self.failIf(affected_file.IsDirectory())
 
   def testIsDirectory(self):
     filename = 'foo.cc'
     f_filename = presubmit.os.path.join(self.fake_root_dir, filename)
     presubmit.os.path.exists(f_filename).AndReturn(True)
     presubmit.os.path.isdir(f_filename).AndReturn(True)
     self.mox.ReplayAll()
-    affected_file = presubmit.SvnAffectedFile(filename, 'A', self.fake_root_dir)
+    affected_file = presubmit.SvnAffectedFile(filename, 'A', self.fake_root_dir,
+                                              None)
     # Verify cache coherency.
     self.failUnless(affected_file.IsDirectory())
     self.failUnless(affected_file.IsDirectory())
 
   def testIsTextFile(self):
     files = [
-        presubmit.SvnAffectedFile('foo/blat.txt', 'M', self.fake_root_dir),
-        presubmit.SvnAffectedFile('foo/binary.blob', 'M', self.fake_root_dir),
-        presubmit.SvnAffectedFile('blat/flop.txt', 'D', self.fake_root_dir)
+        presubmit.SvnAffectedFile('foo/blat.txt', 'M', self.fake_root_dir,
+                                  None),
+        presubmit.SvnAffectedFile('foo/binary.blob', 'M', self.fake_root_dir,
+                                  None),
+        presubmit.SvnAffectedFile('blat/flop.txt', 'D', self.fake_root_dir,
+                                  None)
     ]
     blat = presubmit.os.path.join('foo', 'blat.txt')
     blob = presubmit.os.path.join('foo', 'binary.blob')
     f_blat = presubmit.os.path.join(self.fake_root_dir, blat)
     f_blob = presubmit.os.path.join(self.fake_root_dir, blob)
     presubmit.os.path.exists(f_blat).AndReturn(True)
     presubmit.os.path.isdir(f_blat).AndReturn(False)
     presubmit.os.path.exists(f_blob).AndReturn(True)
     presubmit.os.path.isdir(f_blob).AndReturn(False)
     presubmit.scm.SVN.GetFileProperty(blat, 'svn:mime-type', self.fake_root_dir
@@ skipping 222 matching lines @@
     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, None)
     input_api1 = self.MockInputApi(change1, committing)
     files1 = [
-      presubmit.SvnAffectedFile('foo/bar.cc', 'A', self.fake_root_dir),
-      presubmit.SvnAffectedFile('foo.cc', 'M', self.fake_root_dir),
+      presubmit.SvnAffectedFile('foo/bar.cc', 'A', self.fake_root_dir, None),
+      presubmit.SvnAffectedFile('foo.cc', 'M', self.fake_root_dir, None),
     ]
     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, self.fake_root_dir
         ).AndReturn(value1)
     presubmit.scm.SVN.GetFileProperty(
         presubmit.normpath('foo.cc'), property_name, self.fake_root_dir
         ).AndReturn(value1)
     change2 = presubmit.SvnChange(
         'mychange', '', self.fake_root_dir, [], 0, 0, None)
     input_api2 = self.MockInputApi(change2, committing)
     files2 = [
-      presubmit.SvnAffectedFile('foo/bar.cc', 'A', self.fake_root_dir),
-      presubmit.SvnAffectedFile('foo.cc', 'M', self.fake_root_dir),
+      presubmit.SvnAffectedFile('foo/bar.cc', 'A', self.fake_root_dir, None),
+      presubmit.SvnAffectedFile('foo.cc', 'M', self.fake_root_dir, None),
     ]
     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_name, self.fake_root_dir
         ).AndReturn(value2)
     presubmit.scm.SVN.GetFileProperty(
@@ skipping 345 matching lines @@
     check = presubmit_canned_checks.CheckSvnModifiedDirectories
     results = check(input_api, presubmit.OutputApi, None)
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
                       presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckSvnForCommonMimeTypes(self):
     self.mox.StubOutWithMock(presubmit_canned_checks, 'CheckSvnProperty')
     input_api = self.MockInputApi(None, False)
     output_api = presubmit.OutputApi(False)
-    A = lambda x: presubmit.AffectedFile(x, 'M', self.fake_root_dir)
+    A = lambda x: presubmit.AffectedFile(x, 'M', self.fake_root_dir, None)
     files = [
       A('a.pdf'), A('b.bmp'), A('c.gif'), A('d.png'), A('e.jpg'), A('f.jpe'),
       A('random'), A('g.jpeg'), A('h.ico'),
     ]
     input_api.AffectedFiles(include_deletes=False).AndReturn(files)
     presubmit_canned_checks.CheckSvnProperty(
         input_api, output_api, 'svn:mime-type', 'application/pdf', [files[0]]
         ).AndReturn([1])
     presubmit_canned_checks.CheckSvnProperty(
         input_api, output_api, 'svn:mime-type', 'image/bmp', [files[1]]
@@ skipping 519 matching lines @@
         owners_check=False)
     self.assertEqual(1, len(results))
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()