return a list of uncovered files, not uncovered dirs

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 logging
@@ skipping 2201 matching lines @@
     self.mox.ReplayAll()
 
     results = presubmit_canned_checks.CheckBuildbotPendingBuilds(
         input_api, presubmit.OutputApi, 'uurl', 2, ('foo'))
     self.assertEquals(len(results), 1)
     self.assertEquals(results[0].__class__,
         presubmit.OutputApi.PresubmitNotifyResult)
 
   def AssertOwnersWorks(self, tbr=False, issue='1', approvers=None,
       reviewers=None, is_committing=True, rietveld_response=None,
-      uncovered_dirs=None, expected_output=''):
+      uncovered_files=None, expected_output=''):
     if approvers is None:
       approvers = set()
     if reviewers is None:
       reviewers = set()
     reviewers = reviewers.union(approvers)
-    if uncovered_dirs is None:
-      uncovered_dirs = set()
+    if uncovered_files is None:
+      uncovered_files = set()
 
     change = self.mox.CreateMock(presubmit.Change)
     change.issue = issue
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api = self.MockInputApi(change, False)
     fake_db = self.mox.CreateMock(owners.Database)
     fake_db.email_regexp = input_api.re.compile(owners.BASIC_EMAIL_REGEXP)
     input_api.owners_db = fake_db
     input_api.is_committing = is_committing
     input_api.tbr = tbr
@@ skipping 16 matching lines @@
         people = approvers
       else:
         people = reviewers
 
       if issue:
         input_api.rietveld.get_issue_properties(
             issue=int(input_api.change.issue), messages=True).AndReturn(
                 rietveld_response)
         people.add(owner_email)
 
-      fake_db.directories_not_covered_by(set(['foo/xyz.cc']),
-          people).AndReturn(uncovered_dirs)
-      if not is_committing and uncovered_dirs:
+      fake_db.files_not_covered_by(set(['foo/xyz.cc']),
+          people).AndReturn(uncovered_files)
+      if not is_committing and uncovered_files:
         fake_db.reviewers_for(set(['foo/xyz.cc'])).AndReturn(owner_email)
 
     self.mox.ReplayAll()
     output = presubmit.PresubmitOutput()
     results = presubmit_canned_checks.CheckOwners(input_api,
         presubmit.OutputApi)
     if results:
       results[0].handle(output)
     self.assertEquals(output.getvalue(), expected_output)
 
@@ skipping 66 matching lines @@
 
   def testCannedCheckOwners_NoIssueNoFiles(self):
     self.AssertOwnersWorks(issue=None,
         expected_output="OWNERS check failed: this change has no Rietveld "
                         "issue number, so we can't check it for approvals.\n")
     self.AssertOwnersWorks(issue=None, is_committing=False,
         expected_output="")
 
   def testCannedCheckOwners_NoIssue(self):
     self.AssertOwnersWorks(issue=None,
-        uncovered_dirs=set(['foo']),
+        uncovered_files=set(['foo']),
         expected_output="OWNERS check failed: this change has no Rietveld "
                         "issue number, so we can't check it for approvals.\n")
     self.AssertOwnersWorks(issue=None,
         is_committing=False,
-        uncovered_dirs=set(['foo']),
-        expected_output='Missing OWNER reviewers for files in these '
-                        'directories:\n'
+        uncovered_files=set(['foo']),
+        expected_output='Missing OWNER reviewers for these files:\n'
                         '    foo\n'
                         'Until the issue is uploaded, this list will include '
-                        'directories for which you \n'
-                        'are an OWNER.\n')
+                        'files for which you are an OWNER.\n')
 
   def testCannedCheckOwners_NoLGTM(self):
     self.AssertOwnersWorks(expected_output='Missing LGTM from someone '
                                            'other than john@example.com\n')
     self.AssertOwnersWorks(is_committing=False, expected_output='')
 
   def testCannedCheckOwners_OnlyOwnerLGTM(self):
     self.AssertOwnersWorks(approvers=set(['john@example.com']),
                            expected_output='Missing LGTM from someone '
                                            'other than john@example.com\n')
     self.AssertOwnersWorks(approvers=set(['john@example.com']),
                            is_committing=False,
                            expected_output='')
 
   def testCannedCheckOwners_TBR(self):
     self.AssertOwnersWorks(tbr=True,
         expected_output='--tbr was specified, skipping OWNERS check\n')
     self.AssertOwnersWorks(tbr=True, is_committing=False, expected_output='')
 
   def testCannedCheckOwners_WithoutOwnerLGTM(self):
-    self.AssertOwnersWorks(uncovered_dirs=set(['foo']),
-        expected_output='Missing LGTM from an OWNER for files in these '
-                        'directories:\n'
+    self.AssertOwnersWorks(uncovered_files=set(['foo']),
+        expected_output='Missing LGTM from an OWNER for these files:\n'
                         '    foo\n')
-    self.AssertOwnersWorks(uncovered_dirs=set(['foo']),
-                           is_committing=False,
-        expected_output='Missing OWNER reviewers for files in these '
-                        'directories:\n'
+    self.AssertOwnersWorks(uncovered_files=set(['foo']),
+        is_committing=False,
+        expected_output='Missing OWNER reviewers for these files:\n'
                         '    foo\n')
 
   def testCannedCheckOwners_WithLGTMs(self):
     self.AssertOwnersWorks(approvers=set(['ben@example.com']),
-                           uncovered_dirs=set())
+                           uncovered_files=set())
     self.AssertOwnersWorks(approvers=set(['ben@example.com']),
                            is_committing=False,
-                           uncovered_dirs=set())
+                           uncovered_files=set())
 
   def testCannedRunUnitTests(self):
     change = presubmit.Change(
         'foo1', 'description1', self.fake_root_dir, None, 0, 0, None)
     input_api = self.MockInputApi(change, False)
     input_api.verbose = True
     unit_tests = ['allo', 'bar.py']
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.PresubmitLocalPath().AndReturn(self.fake_root_dir)
     input_api.subprocess.check_call(
@@ skipping 78 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()