Standardize the sys.path fix up and fix a few pylint warnings.

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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 is too confused.
-# pylint: disable=E1101,E1103,R0201,W0212,W0403
+# pylint: disable=E1101,E1103
 
 import logging
+import os
 import StringIO
 import sys
 import time
 
-# Fixes include path.
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
 from super_mox import mox, SuperMoxTestBase
 
 import owners
 import presubmit_support as presubmit
 import rietveld
+
 # Shortcut.
 presubmit_canned_checks = presubmit.presubmit_canned_checks
 
 
 class PresubmitTestsBase(SuperMoxTestBase):
   """Setups and tear downs the mocks but doesn't test anything as-is."""
   presubmit_text = """
 def CheckChangeOnUpload(input_api, output_api):
   if not input_api.change.NOSUCHKEY:
     return [output_api.PresubmitError("!!")]
@@ skipping 194 matching lines @@
 
     presubmit_files = presubmit.ListRelevantPresubmitFiles(files, root_dir)
     self.assertEqual(presubmit_files,
         [
           join(sys_root_dir, 'foo', 'PRESUBMIT.py'),
           join(sys_root_dir, 'foo', 'bar', 'moo', 'PRESUBMIT.py')
         ])
 
   def testTagLineRe(self):
     self.mox.ReplayAll()
-    m = presubmit.Change._TAG_LINE_RE.match(' BUG =1223, 1445  \t')
+    m = presubmit.Change.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')
@@ skipping 1092 matching lines @@
     self.assertEquals(1, len(output))
     self.assertEquals(files[0], output[0])
 
 
 class ChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     members = [
         'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles',
         'DescriptionText', 'FullDescriptionText', 'LocalPaths', 'Name',
         'RepositoryRoot', 'RightHandSideLines', 'ServerPaths',
+        'TAG_LINE_RE',
         'author_email', '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, 'foo')
     self.compareMembers(change, members)
 
   def testMembers(self):
     change = presubmit.Change(
         'foo1', 'foo2\nDRU=ro', self.fake_root_dir, [('Y', 'AA')], 3, 5, 'foo3')
     self.assertEquals('foo1', change.Name())
     self.assertEquals('foo2', change.DescriptionText())
     self.assertEquals('foo3', change.author_email)
     self.assertEquals('ro', change.DRU)
     self.assertEquals(3, change.issue)
     self.assertEquals(5, change.patchset)
     self.assertEquals(self.fake_root_dir, change.RepositoryRoot())
     self.assertEquals(1, len(change.AffectedFiles(include_dirs=True)))
     self.assertEquals('Y', change.AffectedFiles(include_dirs=True)[0].Action())
 
 
 class CannedChecksUnittest(PresubmitTestsBase):
   """Tests presubmit_canned_checks.py."""
 
-  def setUp(self):
-    PresubmitTestsBase.setUp(self)
-
   def MockInputApi(self, change, committing):
+    # pylint: disable=R0201
     input_api = self.mox.CreateMock(presubmit.InputApi)
     input_api.cStringIO = presubmit.cStringIO
     input_api.json = presubmit.json
     input_api.os_listdir = self.mox.CreateMockAnything()
     input_api.os_walk = self.mox.CreateMockAnything()
     input_api.os_path = presubmit.os.path
     input_api.re = presubmit.re
     input_api.rietveld = self.mox.CreateMock(rietveld.Rietveld)
     input_api.traceback = presubmit.traceback
     input_api.urllib2 = self.mox.CreateMock(presubmit.urllib2)
@@ skipping 288 matching lines @@
     # Override the mock of these functions.
     input_api1.FilterSourceFile = lambda x: x
     input_api1.AffectedFiles = test
     self.mox.ReplayAll()
 
     results1 = presubmit_canned_checks.CheckChangeHasNoTabs(input_api1,
         presubmit.OutputApi, None)
     self.assertEquals(len(results1), 1)
     self.assertEquals(results1[0].__class__,
         presubmit.OutputApi.PresubmitPromptWarning)
+    # pylint: disable=W0212
     self.assertEquals(results1[0]._long_text,
         'makefile.foo, line 46')
 
   def testCannedCheckLongLines(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
     self.ContentTest(check, '0123456789', '01234567890',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckLongLinesLF(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
@@ skipping 269 matching lines @@
         ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
         stderr=input_api.subprocess.STDOUT).AndRaise(
             input_api.subprocess.CalledProcessError())
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
                       presubmit.OutputApi.PresubmitNotifyResult)
+    # pylint: disable=W0212
     self.assertEquals('test_module failed!\nfoo', results[0]._message)
 
   def testRunPythonUnitTestsFailureCommitting(self):
     input_api = self.MockInputApi(None, True)
     input_api.subprocess.check_output(
         ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
         stderr=input_api.subprocess.STDOUT).AndRaise(
             input_api.subprocess.CalledProcessError())
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.RunPythonUnitTests(
         input_api, presubmit.OutputApi, ['test_module'])
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__, presubmit.OutputApi.PresubmitError)
+    # pylint: disable=W0212
     self.assertEquals('test_module failed!\nfoo', results[0]._message)
 
   def testRunPythonUnitTestsSuccess(self):
     input_api = self.MockInputApi(None, False)
     input_api.cStringIO = self.mox.CreateMock(presubmit.cStringIO)
     input_api.unittest = self.mox.CreateMock(unittest)
     input_api.subprocess.check_output(
         ['pyyyyython', '-m', 'test_module'], cwd=None, env=None,
         stderr=input_api.subprocess.STDOUT)
     self.mox.ReplayAll()
@@ skipping 220 matching lines @@
     self.mox.ReplayAll()
     results = presubmit_canned_checks.PanProjectChecks(
         input_api,
         presubmit.OutputApi,
         excluded_paths=None,
         text_files=None,
         license_header=None,
         project_name=None,
         owners_check=True)
     self.assertEqual(1, len(results))
+    # pylint: disable=W0212
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()