owners_unittest.py: Add tests of interaction between per-file owners,

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 itertools
 import os
 import sys
 import unittest
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from testing_support import filesystem_mock
 
 import owners
 
 ben = 'ben@example.com'
 brett = 'brett@example.com'
+dana = 'dana@example.com'
 darin = 'darin@example.com'
+elena = 'elena@example.com'
 john = 'john@example.com'
 ken = 'ken@example.com'
 peter = 'peter@example.com'
 tom = 'tom@example.com'
 
-
 def owners_file(*email_addresses, **kwargs):
   s = ''
   if kwargs.get('comment'):
     s += '# %s\n' % kwargs.get('comment')
   if kwargs.get('noparent'):
     s += 'set noparent\n'
   if kwargs.get('file'):
     s += 'file:%s\n' % kwargs.get('file')
   s += '\n'.join(kwargs.get('lines', [])) + '\n'
   return s + '\n'.join(email_addresses) + '\n'
 
 
 def test_repo():
   return filesystem_mock.MockFileSystem(files={
     '/DEPS' : '',
-    '/OWNERS': owners_file(owners.EVERYONE),
+    '/OWNERS': owners_file(dana),
     '/base/vlog.h': '',
     '/chrome/OWNERS': owners_file(ben, brett),
+    '/chrome/chrome.mojom': '',
+    '/chrome/locked.mojom': '',
     '/chrome/browser/OWNERS': owners_file(brett),
     '/chrome/browser/defaults.h': '',
     '/chrome/gpu/OWNERS': owners_file(ken),
     '/chrome/gpu/gpu_channel.h': '',
     '/chrome/renderer/OWNERS': owners_file(peter),
     '/chrome/renderer/gpu/gpu_channel_host.h': '',
     '/chrome/renderer/safe_browsing/scorer.h': '',
+    '/chrome/renderer/safe_browsing/scorer.mojom': '',
     '/content/OWNERS': owners_file(john, darin, comment='foo', noparent=True),
     '/content/content.gyp': '',
     '/content/bar/foo.cc': '',
+    '/content/bar/armchair.mojom': '',
     '/content/baz/OWNERS': owners_file(brett),
     '/content/baz/froboz.h': '',
     '/content/baz/ugly.cc': '',
     '/content/baz/ugly.h': '',
     '/content/garply/OWNERS': owners_file(file='test/OWNERS'),
     '/content/garply/foo.cc': '',
     '/content/garply/test/OWNERS': owners_file(peter),
     '/content/qux/OWNERS': owners_file(peter, file='//content/baz/OWNERS'),
     '/content/qux/foo.cc': '',
     '/content/views/OWNERS': owners_file(ben, john, owners.EVERYONE,
@@ skipping 34 matching lines @@
     self.assertRaises(AssertionError, db.files_not_covered_by,
                       ['/OWNERS'], [])
     db.root = '/'
 
     # Check invalid email address.
     self.assertRaises(AssertionError, db.files_not_covered_by,
                       ['OWNERS'], ['foo'])
 
   def assert_files_not_covered_by(self, files, reviewers, unreviewed_files):
     db = self.db()
-    self.assertEquals(db.files_not_covered_by(set(files), set(reviewers)),
-                      set(unreviewed_files))
+    result = db.files_not_covered_by(set(files), set(reviewers))
+    expected = set(unreviewed_files)
+    if result != expected:
+      raise AssertionError('files_not_covered_by(%s, %s)\n  returned: %s\n  expected: %s' % (list(set(files)), list(set(reviewers)), list(result), list(expected)))
 
   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_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/content.gyp'])
 
   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_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.gyp'])
+      [], ['content/content.gyp', 'chrome/renderer/gpu/gpu_channel_host.h'])
+    self.assert_files_not_covered_by(
+      ['content/content.gyp', 'chrome/renderer/gpu/gpu_channel_host.h', 'content/views/pie.h'],
+      [], ['content/content.gyp', 'chrome/renderer/gpu/gpu_channel_host.h'])
 
   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.gyp',
                                      'content/bar/foo.cc'])
 
   def test_files_not_covered_by__multiple_directories(self):
+    self.files['/OWNERS'] = owners_file(owners.EVERYONE)
     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.gyp', 'content/bar/foo.cc', 'content/baz/froboz.h'])
 
@@ skipping 86 matching lines @@
     # 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().files_not_covered_by, ['DEPS'], [brett])
 
+  def test_per_file_glob_transitive(self):
+    # per-file *.ext rules apply to matching files
+    # in subdirectories, but not across 'set noparent'.
+    self.files['/chrome/OWNERS'] = owners_file(ben, brett,
+                                               lines=['per-file *.mojom=tom@example.com',
+                                                      'per-file locked.mojom=set noparent'])
+    self.files['/OWNERS'] = owners_file(dana,
+                                        lines=['per-file *.mojom=elena@example.com'])
+    # For each file, who we expect to be able to approve it.
+    permissions = {
+      'chrome/chrome.mojom': [dana, tom, elena],
+      'chrome/locked.mojom': [tom],
+      'chrome/renderer/safe_browsing/scorer.mojom': [dana, tom, elena],
+      'chrome/renderer/safe_browsing/scorer.h': [dana, ben],
+      'content/bar/armchair.mojom': [darin],
+    }
+
+    reviewers = set(sum(permissions.values(), []))
+    files = permissions.keys()
+    for reviewer in reviewers:
+      owned_files = set(
+          f for (f, acl) in permissions.iteritems() if reviewer in acl)
+      for num_files in range(1, len(files)+1):
+        for touched_files in itertools.combinations(files, num_files):
+          expected_missing_coverage = set(touched_files) - owned_files
+          self.assert_files_not_covered_by(touched_files, [reviewer],
+                                           expected_missing_coverage)
+
   def test_file_include_absolute_path(self):
     self.assert_files_not_covered_by(['content/qux/foo.cc'], [brett], [])
     self.assert_files_not_covered_by(['content/qux/bar.cc'], [peter], [])
     self.assert_files_not_covered_by(['content/qux/baz.cc'],
                                      [tom], ['content/qux/baz.cc'])
 
   def test_file_include_relative_path(self):
     self.assert_files_not_covered_by(['content/garply/foo.cc'], [peter], [])
     self.assert_files_not_covered_by(['content/garply/bar.cc'], [darin], [])
     self.assert_files_not_covered_by(['content/garply/baz.cc'],
@@ skipping 90 matching lines @@
     self.assertRaises(AssertionError, db.reviewers_for, 'foo', None)
     if hasattr(owners.collections, 'Iterable'):
       self.assertRaises(AssertionError, db.reviewers_for,
                         (f for f in ['x', 'y']), None)
 
     # Check that the files are under the root.
     db.root = '/checkout'
     self.assertRaises(AssertionError, db.reviewers_for, ['/OWNERS'], None)
 
   def test_reviewers_for__wildcard_dir(self):
+    self.files['/OWNERS'] = owners_file(owners.EVERYONE)
     self.assert_reviewers_for(['DEPS'], [['<anyone>']])
     self.assert_reviewers_for(['DEPS', 'chrome/gpu/gpu_channel.h'], [[ken]])
 
   def test_reviewers_for__one_owner(self):
     self.assert_reviewers_for([
         'chrome/gpu/gpu_channel.h',
         'content/baz/froboz.h',
         'chrome/renderer/gpu/gpu_channel_host.h'],
         [[brett]])
 
@@ skipping 146 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()