Add a presubmit check for accidental checkins of files under a SVN modified d...

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 os
 import StringIO
@@ skipping 17 matching lines @@
   elif not input_api.change.REALLYABSOLUTELYNOSUCHKEY:
     return [output_api.PresubmitPromptWarning("??"),
             output_api.PresubmitError("XX!!XX")]
   else:
     return ()
 """
 
   def setUp(self):
     super_mox.SuperMoxTestBase.setUp(self)
     self.mox.StubOutWithMock(presubmit, 'warnings')
-    # Stub out 'os' but keep os.path.dirname/join/normpath/splitext and os.sep.
+    # Stub out 'os' but keep os.path.commonprefix/dirname/join/normpath/splitext
+    # and os.sep.
     os_sep = presubmit.os.sep
+    os_path_commonprefix = presubmit.os.path.commonprefix
+    os_path_dirname = presubmit.os.path.dirname
     os_path_join = presubmit.os.path.join
-    os_path_dirname = presubmit.os.path.dirname
     os_path_normpath = presubmit.os.path.normpath
     os_path_splitext = presubmit.os.path.splitext
     self.mox.StubOutWithMock(presubmit, 'os')
     self.mox.StubOutWithMock(presubmit.os, 'path')
     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, 'random')
     self.mox.StubOutWithMock(presubmit, 'sys')
     presubmit._ASKED_FOR_FEEDBACK = False
     # Special mocks.
     def MockAbsPath(f):
       return f
     presubmit.os.path.abspath = MockAbsPath
+    presubmit.os.path.commonprefix = os_path_commonprefix
     self.fake_root_dir = self.RootDir()
     self.mox.StubOutWithMock(presubmit.gclient, 'CaptureSVNInfo')
     self.mox.StubOutWithMock(presubmit.gcl, 'GetSVNFileProperty')
     self.mox.StubOutWithMock(presubmit.gcl, 'ReadFile')
 
 
 class PresubmitUnittest(PresubmitTestsBase):
   """General presubmit_support.py tests (excluding InputApi and OutputApi)."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
@@ skipping 319 matching lines @@
 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)
     presubmit.random.randint(0, 4).AndReturn(0)
     self.mox.ReplayAll()
-    
+
     output = StringIO.StringIO()
     input = 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))
     text = ('Warning, no presubmit.py found.\n'
             'Running default presubmit script.\n'
             '** Presubmit ERRORS **\n!!\n\n'
@@ skipping 36 matching lines @@
   try:
     y = False
     x = input_api.change.invalid
   except AttributeError:
     y = True
   if not y:
     return [output_api.PresubmitError('Tag parsing failed. 8')]
   if 'TEST' in input_api.change.tags:
     return [output_api.PresubmitError('Tag parsing failed. 3')]
   if input_api.change.DescriptionText() != 'Blah Blah':
-    return [output_api.PresubmitError('Tag parsing failed. 4 ' + 
+    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")
 """
     presubmit.random.randint(0, 4).AndReturn(1)
@@ skipping 18 matching lines @@
     presubmit.os.path.isdir(presubmit.os.path.join(self.fake_root_dir, '.git')
         ).AndReturn(False)
     presubmit.os.path.isdir(presubmit.os.path.join(self.fake_root_dir, '.svn')
         ).AndReturn(False)
     #presubmit.ParseFiles([], None).AndReturn([])
     presubmit.DoPresubmitChecks(mox.IgnoreArg(), False, False,
                                 mox.IgnoreArg(),
                                 mox.IgnoreArg(),
                                 None, False).AndReturn(False)
     self.mox.ReplayAll()
-    
+
     self.assertEquals(True,
                       presubmit.Main(['presubmit', '--root',
                                       self.fake_root_dir]))
 
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
@@ skipping 386 matching lines @@
     self.failIf(warning._Handle(output, input))
     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',
-      'scm',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit.AffectedFile('a', 'b'), members)
     self.compareMembers(presubmit.SvnAffectedFile('a', 'b'), members)
 
   def testAffectedFile(self):
     path = presubmit.os.path.join('foo', 'blat.cc')
     presubmit.os.path.exists(path).AndReturn(True)
     presubmit.os.path.isdir(path).AndReturn(False)
     presubmit.gcl.ReadFile(path).AndReturn('whatever\ncookie')
@@ skipping 56 matching lines @@
     self.failUnless(len(output) == 1)
     self.failUnless(list[0] == output[0])
 
 
 class GclChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     members = [
         'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
         'DescriptionText', 'FullDescriptionText', 'LocalPaths', 'Name',
         'RepositoryRoot', 'RightHandSideLines', 'ServerPaths',
-        'issue', 'patchset', 'tags',
+        '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)
     self.compareMembers(change, members)
 
 
 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
+    input_api.os_path = presubmit.os.path
     input_api.re = presubmit.re
     input_api.traceback = presubmit.traceback
     input_api.urllib2 = self.mox.CreateMock(presubmit.urllib2)
     input_api.unittest = unittest
     input_api.subprocess = self.mox.CreateMock(presubmit.subprocess)
 
     input_api.change = change
     input_api.is_committing = committing
     input_api.python_executable = 'pyyyyython'
     return input_api
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'CheckChangeHasBugField', 'CheckChangeHasDescription',
       'CheckChangeHasNoStrayWhitespace',
       'CheckChangeHasOnlyOneEol', 'CheckChangeHasNoCR',
       'CheckChangeHasNoCrAndHasOnlyOneEol', 'CheckChangeHasNoTabs',
       'CheckChangeHasQaField', 'CheckChangeHasTestedField',
       'CheckChangeHasTestField', 'CheckChangeSvnEolStyle',
+      'CheckSvnModifiedDirectories',
       'CheckSvnForCommonMimeTypes', 'CheckSvnProperty',
       'CheckDoNotSubmit',
       '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):
@@ skipping 58 matching lines @@
     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,
                       error_type, use_source_file):
-    input_api1 = self.MockInputApi(None, committing)
+    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.gcl.GetSVNFileProperty(presubmit.normpath('foo/bar.cc'),
                                      property).AndReturn(value1)
     presubmit.gcl.GetSVNFileProperty(presubmit.normpath('foo.cc'),
                                      property).AndReturn(value1)
-    input_api2 = self.MockInputApi(None, committing)
+    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.gcl.GetSVNFileProperty(presubmit.normpath('foo/bar.cc'),
                                      property).AndReturn(value2)
     presubmit.gcl.GetSVNFileProperty(presubmit.normpath('foo.cc'),
                                      property).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,
                          'Foo\nBUG=1234', 'Foo\n',
                          presubmit.OutputApi.PresubmitNotifyResult,
                          False)
 
   def testCheckChangeHasDescription(self):
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasDescription,
                          'Bleh', '',
                          presubmit.OutputApi.PresubmitNotifyResult,
                          False)
     self.mox.VerifyAll()
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasDescription,
                          'Bleh', '',
                          presubmit.OutputApi.PresubmitError,
                          True)
-  
+
   def testCannedCheckChangeHasTestField(self):
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasTestField,
                          'Foo\nTEST=did some stuff', 'Foo\n',
                          presubmit.OutputApi.PresubmitNotifyResult,
                          False)
 
   def testCannedCheckChangeHasTestedField(self):
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasTestedField,
                          'Foo\nTESTED=did some stuff', 'Foo\n',
                          presubmit.OutputApi.PresubmitError,
@@ skipping 16 matching lines @@
         lambda x,y,z: presubmit_canned_checks.CheckDoNotSubmitInFiles(x, y),
         'DO NOTSUBMIT', 'DO NOT ' + 'SUBMIT',
         presubmit.OutputApi.PresubmitError)
 
   def testCheckChangeHasNoStrayWhitespace(self):
     self.ContentTest(
         lambda x,y,z:
             presubmit_canned_checks.CheckChangeHasNoStrayWhitespace(x, y),
         'Foo', 'Foo ',
         presubmit.OutputApi.PresubmitPromptWarning)
-    
+
 
   def testCheckChangeHasOnlyOneEol(self):
     self.ReadFileTest(presubmit_canned_checks.CheckChangeHasOnlyOneEol,
                       "Hey!\nHo!\n", "Hey!\nHo!\n\n",
                       presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckChangeHasNoCR(self):
     self.ReadFileTest(presubmit_canned_checks.CheckChangeHasNoCR,
                       "Hey!\nHo!\n", "Hey!\r\nHo!\r\n",
                       presubmit.OutputApi.PresubmitPromptWarning)
- 
+
   def testCheckChangeHasNoCrAndHasOnlyOneEol(self):
     self.ReadFileTest(
         presubmit_canned_checks.CheckChangeHasNoCrAndHasOnlyOneEol,
         "Hey!\nHo!\n", "Hey!\nHo!\n\n",
         presubmit.OutputApi.PresubmitPromptWarning)
     self.mox.VerifyAll()
     self.ReadFileTest(
         presubmit_canned_checks.CheckChangeHasNoCrAndHasOnlyOneEol,
         "Hey!\nHo!\n", "Hey!\r\nHo!\r\n",
         presubmit.OutputApi.PresubmitPromptWarning)
@@ skipping 12 matching lines @@
     # 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 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])
+    input_api = self.MockInputApi(change, True)
+
+    affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file.Action().AndReturn('M')
+    affected_file.IsDirectory().AndReturn(True)
+    affected_file.AbsoluteLocalPath().AndReturn(accidental_submssion_file)
+    affected_file.LocalPath().AndReturn(accidental_submssion_file)
+    input_api.AffectedFiles(None).AndReturn([affected_file])
+
+    self.mox.ReplayAll()
+
+    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()
     A = lambda x: presubmit.AffectedFile(x, 'M')
     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)
@@ skipping 139 matching lines @@
     process.communicate().AndReturn(('', ''))
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 0)
 
 
 if __name__ == '__main__':
   unittest.main()