Add InputApi.ReadFile() and presubmit_canned_checks.CheckChangeHasNoCR().

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 random
 import string
@@ skipping 76 matching lines @@
     self.mox.StubOutWithMock(presubmit.gcl, 'ReadFile')
 
   def compareMembers(self, object, members):
     """If you add a member, be sure to add the relevant test!"""
     # Skip over members starting with '_' since they are usually not meant to
     # be for public use.
     actual_members = [x for x in sorted(dir(object))
                       if not x.startswith('_')]
     self.assertEqual(actual_members, sorted(members))
 
+  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)
+
 
 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',
@@ skipping 405 matching lines @@
                        'http://tracker.com/42\n\n'))
 
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
       'DepotToLocalPath', 'LocalPaths', 'LocalToDepotPath',
-      'PresubmitLocalPath', 'RightHandSideLines', 'ServerPaths',
+      'PresubmitLocalPath', 'RightHandSideLines', 'ReadFile', 'ServerPaths',
       'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change',
       'is_committing', 'marshal', 'os_path', 'pickle', 'platform',
       're', 'subprocess', 'tempfile', 'traceback', 'unittest', 'urllib2',
       'version',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit.InputApi(None, './.', False), members)
 
   def testDepotToLocalPath(self):
     presubmit.gclient.CaptureSVNInfo('svn://foo/smurf').AndReturn(
@@ skipping 132 matching lines @@
   def testDeprecated(self):
     presubmit.warnings.warn(mox.IgnoreArg(), category=mox.IgnoreArg(),
                             stacklevel=2)
     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)
     api.AffectedTextFiles(include_deletes=False)
 
+  def testReadFileStringDenied(self):
+    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')
+
+  def testReadFileStringAccepted(self):
+    presubmit.gcl.ReadFile('/AA/boo', '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')
+
+  def testReadFileAffectedFileDenied(self):
+    file = presubmit.AffectedFile('boo', 'M')
+    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')
+
+  def testReadFileAffectedFileAccepted(self):
+    file = presubmit.AffectedFile('/AA/boo', 'M')
+    presubmit.gcl.ReadFile('/AA/boo', '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')
+
 
 class OuputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.OutputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'MailTextResult', 'PresubmitError', 'PresubmitNotifyResult',
       'PresubmitPromptWarning', 'PresubmitResult',
     ]
     # If this test fails, you should add the relevant test.
@@ skipping 144 matching lines @@
                          '_RunPythonUnitTests_LoadTests')
 
   def MockInputApi(self):
     input_api = self.mox.CreateMock(presubmit.InputApi)
     input_api.re = presubmit.re
     input_api.traceback = presubmit.traceback
     input_api.urllib2 = self.mox.CreateMock(presubmit.urllib2)
     input_api.unittest = unittest
     return input_api
 
-  def MakeBasicChange(self, name, description):
-    ci = presubmit.gcl.ChangeInfo(name, 0, 0, description, None)
-    return presubmit.GclChange(ci, self.fake_root_dir)
-
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
-      'CheckChangeHasBugField', 'CheckChangeHasNoTabs',
+      'CheckChangeHasBugField', 'CheckChangeHasNoCR', 'CheckChangeHasNoTabs',
       'CheckChangeHasQaField', 'CheckChangeHasTestedField',
       'CheckChangeHasTestField', 'CheckDoNotSubmit',
       'CheckDoNotSubmitInDescription', 'CheckDoNotSubmitInFiles',
       'CheckLongLines', 'CheckTreeIsOpen', 'RunPythonUnitTests',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit_canned_checks, members)
 
   def TestDescription(self, check, description1, description2, error_type):
     input_api1 = self.MockInputApi()
@@ skipping 58 matching lines @@
   def testCannedCheckDoNotSubmitInDescription(self):
     self.TestDescription(presubmit_canned_checks.CheckDoNotSubmitInDescription,
                          'DO NOTSUBMIT', 'DO NOT ' + 'SUBMIT',
                          presubmit.OutputApi.PresubmitError)
 
   def testCannedCheckDoNotSubmitInFiles(self):
     self.TestContent(presubmit_canned_checks.CheckDoNotSubmitInFiles,
                      'DO NOTSUBMIT', 'DO NOT ' + 'SUBMIT',
                      presubmit.OutputApi.PresubmitError)
 
+  def testCheckChangeHasNoCR(self):
+    input_api1 = self.MockInputApi()
+    self.mox.StubOutWithMock(input_api1, 'ReadFile')
+    input_api1.change = self.MakeBasicChange('foo', 'Foo\n')
+    affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    input_api1.AffectedTextFiles().AndReturn([affected_file1])
+    input_api1.ReadFile(affected_file1, 'rb').AndReturn("Hey!\nHo!\n")
+    input_api2 = self.MockInputApi()
+    self.mox.StubOutWithMock(input_api2, 'ReadFile')
+    input_api2.change = self.MakeBasicChange('foo', 'Foo\n')
+    affected_file2 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    input_api2.AffectedTextFiles().AndReturn([affected_file2])
+    input_api2.ReadFile(affected_file2, 'rb').AndReturn("Hey!\r\nHo!\r\n")
+    affected_file2.LocalPath().AndReturn('bar.cc')
+    self.mox.ReplayAll()
+
+    results = presubmit_canned_checks.CheckChangeHasNoCR(
+        input_api1, presubmit.OutputApi)
+    self.assertEquals(results, [])
+    results2 = presubmit_canned_checks.CheckChangeHasNoCR(
+        input_api2, presubmit.OutputApi)
+    self.assertEquals(len(results2), 1)
+    self.assertEquals(results2[0].__class__,
+                      presubmit.OutputApi.PresubmitPromptWarning)
+  
   def testCannedCheckChangeHasNoTabs(self):
     self.TestContent(presubmit_canned_checks.CheckChangeHasNoTabs,
                      'blah blah', 'blah\tblah',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckLongLines(self):
     check = lambda x,y: presubmit_canned_checks.CheckLongLines(x, y, 10)
     self.TestContent(check, '', 'blah blah blah',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
@@ skipping 145 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()