Create the Next Generation of depot_tools. Eh.

depot_tools/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.py and presubmit_canned_checks.py."""
+
+import os
+import StringIO
+import unittest
+
+# Local imports
+import gcl
+import presubmit
+import presubmit_canned_checks
+
+
+class PresubmitTestsBase(unittest.TestCase):
+  """Setups and tear downs the mocks but doesn't test anything as-is."""
+  def setUp(self):
+    self.original_IsFile = os.path.isfile
+    def MockIsFile(f):
+      dir = os.path.dirname(f)
+      return dir.endswith('haspresubmit') or dir == ''
+    os.path.isfile = MockIsFile
+
+    self.original_GetSVNFileInfo = gcl.GetSVNFileInfo
+    def MockGetSVNFileInfo(path):
+      if path.count('notfound'):
+        return {}
+      results = {
+        'Path': path[len('svn:/foo/'):],
+        'URL': 'svn:/foo/%s' % path.replace('\\', '/'),
+      }
+      if path.endswith('isdir'):
+        results['Node Kind'] = 'directory'
+      else:
+        results['Node Kind'] = 'file'
+      return results
+    gcl.GetSVNFileInfo = MockGetSVNFileInfo
+
+    self.original_GetSVNFileProperty = gcl.GetSVNFileProperty
+    def MockGetSVNFileProperty(path, property_name):
+      if property_name == 'svn:secret-property':
+        return 'secret-property-value'
+      elif path.count('binary'):
+        return 'application/octet-stream'
+      else:
+        if len(path) % 2:
+          return 'text/plain'
+        else:
+          return ''
+    gcl.GetSVNFileProperty = MockGetSVNFileProperty
+
+    self.original_ReadFile = gcl.ReadFile
+    def MockReadFile(path):
+      if path.count('nosuchfile'):
+        return None
+      elif path.endswith('isdir'):
+        self.fail('Should not attempt to read file that is directory.')
+      elif path.endswith('PRESUBMIT.py'):
+        # used in testDoPresubmitChecks
+        return """
+def CheckChangeOnUpload(input_api, output_api):
+  if not input_api.change.NOSUCHKEY:
+    return [output_api.PresubmitError("!!")]
+  elif not input_api.change.REALLYNOSUCHKEY:
+    return [output_api.PresubmitPromptWarning("??")]
+  elif not input_api.change.REALLYABSOLUTELYNOSUCHKEY:
+    return [output_api.PresubmitPromptWarning("??"),
+            output_api.PresubmitError("XX!!XX")]
+  else:
+    return ()
+"""
+      else:
+        return 'one:%s\r\ntwo:%s' % (path, path)
+    gcl.ReadFile = MockReadFile
+
+    self.original_GetRepositoryRoot = gcl.GetRepositoryRoot
+    def MockGetRepositoryRoot():
+      return ''
+    gcl.GetRepositoryRoot = MockGetRepositoryRoot
+
+  def tearDown(self):
+    os.path.isfile = self.original_IsFile
+    gcl.GetSVNFileInfo = self.original_GetSVNFileInfo
+    gcl.GetSVNFileProperty = self.original_GetSVNFileProperty
+    gcl.ReadFile = self.original_ReadFile
+    gcl.GetRepositoryRoot = self.original_GetRepositoryRoot
+
+  @staticmethod
+  def MakeBasicChange(name, description):
+    ci = gcl.ChangeInfo(name=name,
+                        description=description,
+                        files=[])
+    change = presubmit.GclChange(ci)
+    return change
+
+  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))
+
+
+class PresubmitUnittest(PresubmitTestsBase):
+  """General presubmit.py tests (excluding InputApi and OutputApi)."""
+  def testMembersChanged(self):
+    members = [
+      'AffectedFile', 'DoPresubmitChecks', 'GclChange', 'InputApi',
+      'ListRelevantPresubmitFiles', 'Main', 'NotImplementedException',
+      'OutputApi', 'ParseFiles', 'PresubmitExecuter', 'SPECIAL_KEYS',
+      'ScanSubDirs', 'cPickle', 'cStringIO', 'exceptions',
+      'fnmatch', 'gcl', 'glob', 'marshal', 'normpath', 'optparse', 'os',
+      'pickle', 'presubmit_canned_checks', 're', 'subprocess', 'sys',
+      'tempfile', 'types', 'urllib2',
+    ]
+    # If this test fails, you should add the relevant test.
+    self.compareMembers(presubmit, members)
+
+  def testListRelevantPresubmitFiles(self):
+    presubmit_files = presubmit.ListRelevantPresubmitFiles([
+        'blat.cc',
+        'foo/haspresubmit/yodle/smart.h',
+        'moo/mat/gat/yo.h',
+        'foo/luck.h'])
+    self.failUnless(len(presubmit_files) == 2)
+    self.failUnless(presubmit.normpath('PRESUBMIT.py') in presubmit_files)
+    self.failUnless(presubmit.normpath('foo/haspresubmit/PRESUBMIT.py') in
+                    presubmit_files)
+
+  def testTagLineRe(self):
+    m = presubmit._tag_line_re.match(' BUG =1223, 1445  \t')
+    self.failUnless(m)
+    self.failUnlessEqual(m.group('key'), 'BUG')
+    self.failUnlessEqual(m.group('value'), '1223, 1445')
+
+  def testGclChange(self):
+    description_lines = ('Hello there',
+                         'this is a change',
+                         '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
+      ['M', 'flop/notfound.txt'],  # not found in SVN, still exists locally
+      ['D', 'boo/flap.h'],
+    ]
+
+    ci = gcl.ChangeInfo(name='mychange',
+                        description='\n'.join(description_lines),
+                        files=files)
+    change = presubmit.GclChange(ci)
+
+    self.failUnless(change.Change() == 'mychange')
+    self.failUnless(change.Changelist() == '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.BugIDs == '123')
+    self.failUnless(change.BUG == '123')
+    self.failUnless(change.STORY == 'http://foo/')
+
+    self.failUnless(len(change.AffectedFiles()) == 4)
+    self.failUnless(len(change.AffectedFiles(include_dirs=True)) == 5)
+    self.failUnless(len(change.AffectedFiles(include_deletes=False)) == 3)
+    self.failUnless(len(change.AffectedFiles(include_dirs=True,
+                                             include_deletes=False)) == 4)
+
+    affected_text_files = change.AffectedTextFiles(include_deletes=True)
+    self.failUnless(len(affected_text_files) == 3)
+    self.failIf(filter(lambda x: x.LocalPath() == 'binary.dll',
+                       affected_text_files))
+
+    local_paths = change.LocalPaths()
+    expected_paths = [presubmit.normpath(f[1]) for f in files]
+    self.failUnless(
+        len(filter(lambda x: x in expected_paths, local_paths)) == 4)
+
+    server_paths = change.ServerPaths()
+    expected_paths = ['svn:/foo/%s' % f[1] for f in files if
+                      f[1] != 'flop/notfound.txt']
+    expected_paths.append('')  # one unknown file
+    self.failUnless(
+      len(filter(lambda x: x in expected_paths, server_paths)) == 4)
+
+    files = [[x[0], presubmit.normpath(x[1])] for x in files]
+
+    rhs_lines = []
+    for line in change.RightHandSideLines():
+      rhs_lines.append(line)
+    self.failUnless(rhs_lines[0][0].LocalPath() == files[0][1])
+    self.failUnless(rhs_lines[0][1] == 1)
+    self.failUnless(rhs_lines[0][2] == 'one:%s' % files[0][1])
+
+    self.failUnless(rhs_lines[1][0].LocalPath() == files[0][1])
+    self.failUnless(rhs_lines[1][1] == 2)
+    self.failUnless(rhs_lines[1][2] == 'two:%s' % files[0][1])
+
+    self.failUnless(rhs_lines[2][0].LocalPath() == files[3][1])
+    self.failUnless(rhs_lines[2][1] == 1)
+    self.failUnless(rhs_lines[2][2] == 'one:%s' % files[3][1])
+
+    self.failUnless(rhs_lines[3][0].LocalPath() == files[3][1])
+    self.failUnless(rhs_lines[3][1] == 2)
+    self.failUnless(rhs_lines[3][2] == 'two:%s' % files[3][1])
+
+  def testAffectedFile(self):
+    af = presubmit.AffectedFile('foo/blat.cc', 'M')
+    self.failUnless(af.ServerPath() == 'svn:/foo/foo/blat.cc')
+    self.failUnless(af.LocalPath() == presubmit.normpath('foo/blat.cc'))
+    self.failUnless(af.Action() == 'M')
+    self.failUnless(af.NewContents() == ['one:%s' % af.LocalPath(),
+                                         'two:%s' % af.LocalPath()])
+
+    af = presubmit.AffectedFile('notfound.cc', 'A')
+    self.failUnless(af.ServerPath() == '')
+
+  def testExecPresubmitScript(self):
+    description_lines = ('Hello there',
+                         'this is a change',
+                         'STORY=http://tracker/123')
+    files = [
+      ['A', 'foo\\blat.cc'],
+    ]
+    ci = gcl.ChangeInfo(name='mychange',
+                        description='\n'.join(description_lines),
+                        files=files)
+
+    executer = presubmit.PresubmitExecuter(ci, False)
+    self.failIf(executer.ExecPresubmitScript('', 'PRESUBMIT.py'))
+    # No error if no on-upload entry point
+    self.failIf(executer.ExecPresubmitScript(
+      ('def CheckChangeOnCommit(input_api, output_api):\n'
+       '  return (output_api.PresubmitError("!!"))\n'),
+      'PRESUBMIT.py'
+    ))
+
+    executer = presubmit.PresubmitExecuter(ci, True)
+    # No error if no on-commit entry point
+    self.failIf(executer.ExecPresubmitScript(
+      ('def CheckChangeOnUpload(input_api, output_api):\n'
+       '  return (output_api.PresubmitError("!!"))\n'),
+      'PRESUBMIT.py'
+    ))
+
+    self.failIf(executer.ExecPresubmitScript(
+      ('def CheckChangeOnUpload(input_api, output_api):\n'
+       '  if not input_api.change.STORY:\n'
+       '    return (output_api.PresubmitError("!!"))\n'
+       '  else:\n'
+       '    return ()'),
+      'PRESUBMIT.py'
+    ))
+
+    self.failUnless(executer.ExecPresubmitScript(
+      ('def CheckChangeOnCommit(input_api, output_api):\n'
+       '  if not input_api.change.NOSUCHKEY:\n'
+       '    return [output_api.PresubmitError("!!")]\n'
+       '  else:\n'
+       '    return ()'),
+      'PRESUBMIT.py'
+    ))
+
+    try:
+      executer.ExecPresubmitScript(
+        ('def CheckChangeOnCommit(input_api, output_api):\n'
+         '  return "foo"'),
+        'PRESUBMIT.py')
+      self.fail()
+    except:
+      pass  # expected case
+
+    try:
+      executer.ExecPresubmitScript(
+        ('def CheckChangeOnCommit(input_api, output_api):\n'
+         '  return ["foo"]'),
+        'PRESUBMIT.py')
+      self.fail()
+    except:
+      pass  # expected case
+
+  def testDoPresubmitChecks(self):
+    description_lines = ('Hello there',
+                         'this is a change',
+                         'STORY=http://tracker/123')
+    files = [
+      ['A', 'haspresubmit\\blat.cc'],
+    ]
+    ci = gcl.ChangeInfo(name='mychange',
+                        description='\n'.join(description_lines),
+                        files=files)
+
+    output = StringIO.StringIO()
+    input = StringIO.StringIO('y\n')
+
+    self.failIf(presubmit.DoPresubmitChecks(ci, False, False, output, input,
+                                            None))
+    self.assertEqual(output.getvalue().count('!!'), 2)
+
+  def testDoPresubmitChecksPromptsAfterWarnings(self):
+    description_lines = ('Hello there',
+                         'this is a change',
+                         'NOSUCHKEY=http://tracker/123')
+    files = [
+      ['A', 'haspresubmit\\blat.cc'],
+    ]
+    ci = gcl.ChangeInfo(name='mychange',
+                        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, False, output, input,
+                                            None))
+    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,
+                                                False,
+                                                output,
+                                                input,
+                                                None))
+    self.failUnless(output.getvalue().count('??'))
+
+  def testDoPresubmitChecksNoWarningPromptIfErrors(self):
+    description_lines = ('Hello there',
+                         'this is a change',
+                         'NOSUCHKEY=http://tracker/123',
+                         'REALLYNOSUCHKEY=http://tracker/123')
+    files = [
+      ['A', 'haspresubmit\\blat.cc'],
+    ]
+    ci = gcl.ChangeInfo(name='mychange',
+                        description='\n'.join(description_lines),
+                        files=files)
+
+    output = StringIO.StringIO()
+    input = StringIO.StringIO()  # should be unused
+
+    self.failIf(presubmit.DoPresubmitChecks(ci, False, False, output, input,
+                                            None))
+    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):
+    description_lines = ('Hello there',
+                         'this is a change',
+                         'STORY=http://tracker/123')
+    files = [
+      ['A', 'haspresubmit\\blat.cc'],
+    ]
+    ci = gcl.ChangeInfo(name='mychange',
+                        description='\n'.join(description_lines),
+                        files=files)
+
+    output = StringIO.StringIO()
+    input = StringIO.StringIO('y\n')
+    DEFAULT_SCRIPT = """
+def CheckChangeOnUpload(input_api, output_api):
+  return [output_api.PresubmitError("!!")]
+"""
+    def MockReadFile(dummy):
+      return ''
+    gcl.ReadFile = MockReadFile
+    def MockIsFile(dummy):
+      return False
+    os.path.isfile = MockIsFile
+    self.failUnless(presubmit.DoPresubmitChecks(ci, False, False, output, input,
+                                                DEFAULT_SCRIPT))
+    self.failIf(output.getvalue().count('!!') == 1)
+
+  def testDirectoryHandling(self):
+    files = [
+      ['A', 'isdir'],
+      ['A', 'isdir\\blat.cc'],
+    ]
+    ci = gcl.ChangeInfo(name='mychange',
+                        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 testSvnProperty(self):
+    affected_file = presubmit.AffectedFile('foo.cc', 'A')
+    self.failUnless(affected_file.SvnProperty('svn:secret-property') ==
+                    'secret-property-value')
+
+
+class InputApiUnittest(PresubmitTestsBase):
+  """Tests presubmit.InputApi."""
+  def testMembersChanged(self):
+    members = [
+      'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
+      'DepotToLocalPath', 'FilterTextFiles', 'LocalPaths', 'LocalToDepotPath',
+      'PresubmitLocalPath', 'RightHandSideLines', 'ServerPaths',
+      'basename', 'cPickle', 'cStringIO', 'canned_checks', 'change',
+      'current_presubmit_path', 'marshal', 'os_path', 'pickle', 'platform',
+      're', 'subprocess', 'tempfile', 'urllib2',
+    ]
+    # If this test fails, you should add the relevant test.
+    self.compareMembers(presubmit.InputApi(None, None), members)
+
+  def testDepotToLocalPath(self):
+    path = presubmit.InputApi.DepotToLocalPath('svn:/foo/smurf')
+    self.failUnless(path == 'smurf')
+    path = presubmit.InputApi.DepotToLocalPath('svn:/foo/notfound/burp')
+    self.failUnless(path == None)
+
+  def testLocalToDepotPath(self):
+    path = presubmit.InputApi.LocalToDepotPath('smurf')
+    self.failUnless(path == 'svn:/foo/smurf')
+    path = presubmit.InputApi.LocalToDepotPath('notfound-food')
+    self.failUnless(path == None)
+
+  def testInputApiConstruction(self):
+    # Fudge the change object, it's not used during construction anyway
+    api = presubmit.InputApi(change=42, presubmit_path='foo/path')
+    self.failUnless(api.PresubmitLocalPath() == 'foo/path')
+    self.failUnless(api.change == 42)
+
+  def testFilterTextFiles(self):
+    class MockAffectedFile(object):
+      def __init__(self, path, action):
+        self.path = path
+        self.action = action
+      def Action(self):
+        return self.action
+      def LocalPath(self):
+        return self.path
+      def AbsoluteLocalPath(self):
+        return self.path
+
+    list = [MockAffectedFile('foo/blat.txt', 'M'),
+            MockAffectedFile('foo/binary.blob', 'M'),
+            MockAffectedFile('blat/flop.txt', 'D')]
+
+    output = presubmit.InputApi.FilterTextFiles(list, include_deletes=True)
+    self.failUnless(len(output) == 2)
+    self.failUnless(list[0] in output and list[2] in output)
+
+    output = presubmit.InputApi.FilterTextFiles(list, include_deletes=False)
+    self.failUnless(len(output) == 1)
+    self.failUnless(list[0] in output)
+
+  def testInputApiPresubmitScriptFiltering(self):
+    description_lines = ('Hello there',
+                         'this is a change',
+                         'BUG=123',
+                         ' STORY =http://foo/  \t',
+                         'and some more regular text')
+    files = [
+      ['A', os.path.join('foo', 'blat.cc')],
+      ['M', os.path.join('foo', 'blat', 'binary.dll')],
+      ['D', 'foo/mat/beingdeleted.txt'],
+      ['M', 'flop/notfound.txt'],
+      ['A', 'boo/flap.h'],
+    ]
+
+    ci = gcl.ChangeInfo(name='mychange',
+                        description='\n'.join(description_lines),
+                        files=files)
+    change = presubmit.GclChange(ci)
+
+    api = presubmit.InputApi(change, 'foo/PRESUBMIT.py')
+
+    affected_files = api.AffectedFiles()
+    self.failUnless(len(affected_files) == 3)
+    self.failUnless(affected_files[0].LocalPath() ==
+                    presubmit.normpath('foo/blat.cc'))
+    self.failUnless(affected_files[1].LocalPath() ==
+                    presubmit.normpath('foo/blat/binary.dll'))
+    self.failUnless(affected_files[2].LocalPath() ==
+                    presubmit.normpath('foo/mat/beingdeleted.txt'))
+
+    rhs_lines = []
+    for line in api.RightHandSideLines():
+      rhs_lines.append(line)
+    self.failUnless(len(rhs_lines) == 2)
+    self.failUnless(rhs_lines[0][0].LocalPath() ==
+                    presubmit.normpath('foo/blat.cc'))
+
+  def testGetAbsoluteLocalPath(self):
+    # 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', os.path.join('isdir', 'blat.cc')]
+    ]
+    ci = gcl.ChangeInfo(name='mychange',
+                        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, 'c:' + os.sep + 'temp')
+    affected_files = change.AffectedFiles(include_dirs=True)
+    # Local paths should remain the same
+    self.failUnless(affected_files[0].LocalPath() ==
+                    presubmit.normpath('isdir'))
+    self.failUnless(affected_files[1].LocalPath() ==
+                    presubmit.normpath('isdir/blat.cc'))
+    # Absolute paths should be prefixed
+    self.failUnless(affected_files[0].AbsoluteLocalPath() ==
+                    presubmit.normpath('c:/temp/isdir'))
+    self.failUnless(affected_files[1].AbsoluteLocalPath() ==
+                    presubmit.normpath('c:/temp/isdir/blat.cc'))
+
+    # New helper functions need to work
+    absolute_paths_from_change = change.AbsoluteLocalPaths(include_dirs=True)
+    api = presubmit.InputApi(change=change, presubmit_path='isdir/PRESUBMIT.py')
+    absolute_paths_from_api = api.AbsoluteLocalPaths(include_dirs=True)
+    for absolute_paths in [absolute_paths_from_change,
+                           absolute_paths_from_api]:
+      self.failUnless(absolute_paths[0] == presubmit.normpath('c:/temp/isdir'))
+      self.failUnless(absolute_paths[1] ==
+                      presubmit.normpath('c:/temp/isdir/blat.cc'))
+
+
+class OuputApiUnittest(PresubmitTestsBase):
+  """Tests presubmit.OutputApi."""
+  def testMembersChanged(self):
+    members = [
+      'MailTextResult', 'PresubmitError', 'PresubmitNotifyResult',
+      'PresubmitPromptWarning', 'PresubmitResult',
+    ]
+    # If this test fails, you should add the relevant test.
+    self.compareMembers(presubmit.OutputApi(), members)
+
+  def testOutputApiBasics(self):
+    self.failUnless(presubmit.OutputApi.PresubmitError('').IsFatal())
+    self.failIf(presubmit.OutputApi.PresubmitError('').ShouldPrompt())
+
+    self.failIf(presubmit.OutputApi.PresubmitPromptWarning('').IsFatal())
+    self.failUnless(
+        presubmit.OutputApi.PresubmitPromptWarning('').ShouldPrompt())
+
+    self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').IsFatal())
+    self.failIf(presubmit.OutputApi.PresubmitNotifyResult('').ShouldPrompt())
+
+    # TODO(joi) Test MailTextResult once implemented.
+
+  def testOutputApiHandling(self):
+    output = StringIO.StringIO()
+    unused_input = StringIO.StringIO()
+    error = presubmit.OutputApi.PresubmitError('!!!')
+    self.failIf(error._Handle(output, unused_input))
+    self.failUnless(output.getvalue().count('!!!'))
+
+    output = StringIO.StringIO()
+    notify = presubmit.OutputApi.PresubmitNotifyResult('?see?')
+    self.failUnless(notify._Handle(output, unused_input))
+    self.failUnless(output.getvalue().count('?see?'))
+
+    output = StringIO.StringIO()
+    input = StringIO.StringIO('y')
+    warning = presubmit.OutputApi.PresubmitPromptWarning('???')
+    self.failUnless(warning._Handle(output, input))
+    self.failUnless(output.getvalue().count('???'))
+
+    output = StringIO.StringIO()
+    input = StringIO.StringIO('n')
+    warning = presubmit.OutputApi.PresubmitPromptWarning('???')
+    self.failIf(warning._Handle(output, input))
+    self.failUnless(output.getvalue().count('???'))
+
+    output = StringIO.StringIO()
+    input = StringIO.StringIO('\n')
+    warning = presubmit.OutputApi.PresubmitPromptWarning('???')
+    self.failIf(warning._Handle(output, input))
+    self.failUnless(output.getvalue().count('???'))
+
+
+class CannedChecksUnittest(PresubmitTestsBase):
+  """Tests presubmit_canned_checks.py."""
+  class MockInputApi(object):
+    class MockUrllib2(object):
+      class urlopen(object):
+        def __init__(self, url):
+          if url == 'url_to_open':
+            self.result = '1'
+          else:
+            self.result = '0'
+        def read(self):
+          return self.result
+        def close(self):
+          pass
+    def __init__(self, lines=None):
+      self.lines = lines
+      self.basename = lambda x: x
+      self.urllib2 = self.MockUrllib2()
+      self.re = presubmit.re
+
+    def RightHandSideLines(self):
+      for line in self.lines:
+        yield (presubmit.AffectedFile('bingo', 'M'), 1, line)
+
+  def testMembersChanged(self):
+    members = [
+      'CheckChangeHasNoTabs', 'CheckChangeHasQaField',
+      'CheckChangeHasTestedField', 'CheckDoNotSubmit',
+      'CheckDoNotSubmitInDescription', 'CheckDoNotSubmitInFiles',
+      'CheckLongLines', 'CheckTreeIsOpen',
+    ]
+    # If this test fails, you should add the relevant test.
+    self.compareMembers(presubmit_canned_checks, members)
+
+  def testCannedCheckChangeHasTestedField(self):
+    change = self.MakeBasicChange('foo',
+                                  'Foo\nTESTED=did some stuff')
+    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    self.failIf(presubmit_canned_checks.CheckChangeHasTestedField(
+        api, presubmit.OutputApi))
+
+    change = self.MakeBasicChange('foo',
+                                  'Foo\nNEVERTESTED=did some stuff')
+    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    self.failUnless(presubmit_canned_checks.CheckChangeHasTestedField(
+        api, presubmit.OutputApi))
+
+  def testCannedCheckChangeHasQAField(self):
+    change = self.MakeBasicChange('foo',
+                                  'Foo\nQA=test floop feature very well')
+    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    self.failIf(presubmit_canned_checks.CheckChangeHasQaField(
+        api, presubmit.OutputApi))
+
+    change = self.MakeBasicChange('foo',
+                                  'Foo\nNOTFORQA=test floop feature very well')
+    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    self.failUnless(presubmit_canned_checks.CheckChangeHasQaField(
+        api, presubmit.OutputApi))
+
+  def testCannedCheckDoNotSubmitInDescription(self):
+    change = self.MakeBasicChange('foo', 'hello')
+    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    self.failIf(presubmit_canned_checks.CheckDoNotSubmitInDescription(
+        api, presubmit.OutputApi))
+
+    change = self.MakeBasicChange('foo',
+                                  'DO NOT ' + 'SUBMIT')
+    api = presubmit.InputApi(change, 'PRESUBMIT.py')
+    self.failUnless(presubmit_canned_checks.CheckDoNotSubmitInDescription(
+        api, presubmit.OutputApi))
+
+  def testCannedCheckDoNotSubmitInFiles(self):
+    self.failIf(presubmit_canned_checks.CheckDoNotSubmitInFiles(
+      self.MockInputApi(['hello', 'there']), presubmit.OutputApi
+    ))
+    self.failUnless(presubmit_canned_checks.CheckDoNotSubmitInFiles(
+      self.MockInputApi(['hello', 'yo, DO NOT ' + 'SUBMIT']),
+                      presubmit.OutputApi))
+
+  def testCannedCheckChangeHasNoTabs(self):
+    self.failIf(presubmit_canned_checks.CheckChangeHasNoTabs(
+      self.MockInputApi(['hello', 'there']), presubmit.OutputApi
+    ))
+    self.failUnless(presubmit_canned_checks.CheckChangeHasNoTabs(
+      self.MockInputApi(['hello', 'there\tit is']), presubmit.OutputApi
+    ))
+
+  def testCannedCheckLongLines(self):
+    self.failIf(presubmit_canned_checks.CheckLongLines(
+      self.MockInputApi(['hello', 'there']), presubmit.OutputApi, 5
+    ))
+    self.failUnless(presubmit_canned_checks.CheckLongLines(
+      self.MockInputApi(['hello', 'there!']), presubmit.OutputApi, 5
+    ))
+
+  def testCannedCheckTreeIsOpen(self):
+    self.failIf(presubmit_canned_checks.CheckTreeIsOpen(
+      self.MockInputApi(), presubmit.OutputApi, url='url_to_open', closed='0'
+    ))
+    self.failUnless(presubmit_canned_checks.CheckTreeIsOpen(
+      self.MockInputApi(), presubmit.OutputApi, url='url_to_closed', closed='0'
+    ))
+
+
+if __name__ == '__main__':
+  unittest.main()