return a list of uncovered files, not uncovered dirs

tests/owners_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 owners.py."""
 
 import os
 import sys
 import unittest
@@ skipping 62 matching lines @@
     fopen = fopen or self.fopen
     os_path = os_path or self.repo
     glob = glob or self.glob
     return owners.Database(root, fopen, os_path, glob)
 
 
 class OwnersDatabaseTest(_BaseTestCase):
   def test_constructor(self):
     self.assertNotEquals(self.db(), None)
 
-  def test_dirs_not_covered_by__valid_inputs(self):
+  def test_files_not_covered_by__valid_inputs(self):
     db = self.db()
 
     # Check that we're passed in a sequence that isn't a string.
-    self.assertRaises(AssertionError, db.directories_not_covered_by, 'foo', [])
+    self.assertRaises(AssertionError, db.files_not_covered_by, 'foo', [])
     if hasattr(owners.collections, 'Iterable'):
-      self.assertRaises(AssertionError, db.directories_not_covered_by,
+      self.assertRaises(AssertionError, db.files_not_covered_by,
                         (f for f in ['x', 'y']), [])
 
     # Check that the files are under the root.
     db.root = '/checkout'
-    self.assertRaises(AssertionError, db.directories_not_covered_by,
+    self.assertRaises(AssertionError, db.files_not_covered_by,
                       ['/OWNERS'], [])
     db.root = '/'
 
     # Check invalid email address.
-    self.assertRaises(AssertionError, db.directories_not_covered_by,
+    self.assertRaises(AssertionError, db.files_not_covered_by,
                       ['OWNERS'], ['foo'])
 
-  def assert_dirs_not_covered_by(self, files, reviewers, unreviewed_dirs):
+  def assert_files_not_covered_by(self, files, reviewers, unreviewed_files):
     db = self.db()
-    self.assertEquals(
-        db.directories_not_covered_by(set(files), set(reviewers)),
-        set(unreviewed_dirs))
+    self.assertEquals(db.files_not_covered_by(set(files), set(reviewers)),
+                      set(unreviewed_files))
 
-  def test_dirs_not_covered_by__owners_propagates_down(self):
-    self.assert_dirs_not_covered_by(
+  def test_files_not_covered_by__owners_propagates_down(self):
+    self.assert_files_not_covered_by(
       ['chrome/gpu/gpu_channel.h', 'chrome/renderer/gpu/gpu_channel_host.h'],
       [ben], [])
 
-  def test_dirs_not_covered_by__partial_covering(self):
-    self.assert_dirs_not_covered_by(
+  def test_files_not_covered_by__partial_covering(self):
+    self.assert_files_not_covered_by(
       ['content/content.gyp', 'chrome/renderer/gpu/gpu_channel_host.h'],
-      [peter], ['content'])
+      [peter], ['content/content.gyp'])
 
-  def test_dirs_not_covered_by__set_noparent_works(self):
-    self.assert_dirs_not_covered_by(['content/content.gyp'], [ben],
-                                    ['content'])
+  def test_files_not_covered_by__set_noparent_works(self):
+    self.assert_files_not_covered_by(['content/content.gyp'], [ben],
+                                    ['content/content.gyp'])
 
-  def test_dirs_not_covered_by__no_reviewer(self):
-    self.assert_dirs_not_covered_by(
+  def test_files_not_covered_by__no_reviewer(self):
+    self.assert_files_not_covered_by(
       ['content/content.gyp', 'chrome/renderer/gpu/gpu_channel_host.h'],
-      [], ['content'])
+      [], ['content/content.gyp'])
 
-  def test_dirs_not_covered_by__combines_directories(self):
-    self.assert_dirs_not_covered_by(['content/content.gyp',
+  def test_files_not_covered_by__combines_directories(self):
+    self.assert_files_not_covered_by(['content/content.gyp',
                                      'content/bar/foo.cc',
                                      'chrome/renderer/gpu/gpu_channel_host.h'],
                                     [peter],
-                                    ['content'])
+                                    ['content/content.gyp',
+                                     'content/bar/foo.cc'])
 
-  def test_dirs_not_covered_by__multiple_directories(self):
-    self.assert_dirs_not_covered_by(
+  def test_files_not_covered_by__multiple_directories(self):
+    self.assert_files_not_covered_by(
         ['content/content.gyp',                    # Not covered
          'content/bar/foo.cc',                     # Not covered (combines in)
          'content/baz/froboz.h',                   # Not covered
          'chrome/gpu/gpu_channel.h',               # Owned by ken
          'chrome/renderer/gpu/gpu_channel_host.h'  # Owned by * via parent
         ],
         [ken],
-        ['content', 'content/baz'])
+        ['content/content.gyp', 'content/bar/foo.cc', 'content/baz/froboz.h'])
 
   def test_per_file(self):
     # brett isn't allowed to approve ugly.cc
     self.files['/content/baz/OWNERS'] = owners_file(brett,
         lines=['per-file ugly.*=tom@example.com'])
-    self.assert_dirs_not_covered_by(['content/baz/ugly.cc'],
+    self.assert_files_not_covered_by(['content/baz/ugly.cc'],
                                     [brett],
                                     [])
 
     # tom is allowed to approve ugly.cc, but not froboz.h
-    self.assert_dirs_not_covered_by(['content/baz/ugly.cc'],
+    self.assert_files_not_covered_by(['content/baz/ugly.cc'],
                                     [tom],
                                     [])
-    self.assert_dirs_not_covered_by(['content/baz/froboz.h'],
+    self.assert_files_not_covered_by(['content/baz/froboz.h'],
                                     [tom],
-                                    ['content/baz'])
+                                    ['content/baz/froboz.h'])
 
   def test_per_file_with_spaces(self):
     # This is the same as test_per_file(), except that we include spaces
     # on the per-file line. brett isn't allowed to approve ugly.cc;
     # tom is allowed to approve ugly.cc, but not froboz.h
     self.files['/content/baz/OWNERS'] = owners_file(brett,
         lines=['per-file ugly.* = tom@example.com'])
-    self.assert_dirs_not_covered_by(['content/baz/ugly.cc'],
+    self.assert_files_not_covered_by(['content/baz/ugly.cc'],
                                     [brett],
                                     [])
 
-    self.assert_dirs_not_covered_by(['content/baz/ugly.cc'],
+    self.assert_files_not_covered_by(['content/baz/ugly.cc'],
                                     [tom],
                                     [])
-    self.assert_dirs_not_covered_by(['content/baz/froboz.h'],
+    self.assert_files_not_covered_by(['content/baz/froboz.h'],
                                     [tom],
-                                    ['content/baz'])
+                                    ['content/baz/froboz.h'])
 
   def test_per_file__set_noparent(self):
     self.files['/content/baz/OWNERS'] = owners_file(brett,
         lines=['per-file ugly.*=tom@example.com',
                'per-file ugly.*=set noparent'])
 
     # brett isn't allowed to approve ugly.cc
-    self.assert_dirs_not_covered_by(['content/baz/ugly.cc'],
+    self.assert_files_not_covered_by(['content/baz/ugly.cc'],
                                     [brett],
                                     ['content/baz/ugly.cc'])
 
     # tom is allowed to approve ugly.cc, but not froboz.h
-    self.assert_dirs_not_covered_by(['content/baz/ugly.cc'],
+    self.assert_files_not_covered_by(['content/baz/ugly.cc'],
                                     [tom],
                                     [])
 
-    self.assert_dirs_not_covered_by(['content/baz/froboz.h'],
+    self.assert_files_not_covered_by(['content/baz/froboz.h'],
                                     [tom],
-                                    ['content/baz'])
+                                    ['content/baz/froboz.h'])
 
   def test_per_file_wildcard(self):
     self.files['/OWNERS'] = 'per-file DEPS=*\n'
-    self.assert_dirs_not_covered_by(['DEPS'], [brett], [])
+    self.assert_files_not_covered_by(['DEPS'], [brett], [])
 
   def test_mock_relpath(self):
     # This test ensures the mock relpath has the arguments in the right
     # order; this should probably live someplace else.
     self.assertEquals(self.repo.relpath('foo/bar.c', 'foo/'), 'bar.c')
     self.assertEquals(self.repo.relpath('/bar.c', '/'), 'bar.c')
 
   def test_per_file_glob_across_dirs_not_allowed(self):
     self.files['/OWNERS'] = 'per-file content/*=john@example.org\n'
     self.assertRaises(owners.SyntaxErrorInOwnersFile,
-        self.db().directories_not_covered_by, ['DEPS'], [brett])
+        self.db().files_not_covered_by, ['DEPS'], [brett])
 
   def assert_syntax_error(self, owners_file_contents):
     db = self.db()
     self.files['/foo/OWNERS'] = owners_file_contents
     self.files['/foo/DEPS'] = ''
     try:
       db.reviewers_for(['foo/DEPS'])
       self.fail()  # pragma: no cover
     except owners.SyntaxErrorInOwnersFile, e:
       self.assertTrue(str(e).startswith('/foo/OWNERS:1'))
@@ skipping 165 matching lines @@
                       ('chrome/browser', 2)],
                 ken: [('chrome/gpu', 1)],
                 peter: [('chrome/renderer', 1)],
                 brett: [('chrome/browser', 1)]},
                ['chrome/gpu', 'chrome/renderer',
                 'chrome/browser'],
                ben)
 
 if __name__ == '__main__':
   unittest.main()