Support multiple try masters when sending tries to rietveld.

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 functools
+import itertools
 import logging
 import os
 import StringIO
 import sys
 import time
 import unittest
 
 _ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, _ROOT)
 
@@ skipping 32 matching lines @@
 """
 
   presubmit_tryslave_project = """
 def GetPreferredTrySlaves(project):
   if project == %s:
     return %s
   else:
     return %s
 """
 
+  presubmit_trymaster = """
+def GetPreferredTryMasters(project, change):
+  return %s
+"""
+
   presubmit_diffs = """
 --- file1       2011-02-09 10:38:16.517224845 -0800
 +++ file2       2011-02-09 10:38:53.177226516 -0800
 @@ -1,6 +1,5 @@
  this is line number 0
  this is line number 1
 -this is line number 2 to be deleted
  this is line number 3
  this is line number 4
  this is line number 5
@@ skipping 90 matching lines @@
       'GetTrySlavesExecuter', 'GitAffectedFile', 'CallCommand', 'CommandData',
       'GitChange', 'InputApi', 'ListRelevantPresubmitFiles', 'Main',
       'NonexistantCannedCheckFilter', 'OutputApi', 'ParseFiles',
       'PresubmitFailure', 'PresubmitExecuter', 'PresubmitOutput', 'ScanSubDirs',
       'SvnAffectedFile', 'SvnChange', 'cPickle', 'cpplint', 'cStringIO',
       'contextlib', 'canned_check_filter', 'fix_encoding', 'fnmatch',
       'gclient_utils', 'glob', 'inspect', 'json', 'load_files', 'logging',
       'marshal', 'normpath', 'optparse', 'os', 'owners', 'pickle',
       'presubmit_canned_checks', 'random', 're', 'rietveld', 'scm',
       'subprocess', 'sys', 'tempfile', 'time', 'traceback', 'types', 'unittest',
-      'urllib2', 'warn', 'multiprocessing',
+      'urllib2', 'warn', 'multiprocessing', 'DoGetTryMasters',
+      'GetTryMastersExecuter', 'itertools',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit, members)
 
   def testCannedCheckFilter(self):
     canned = presubmit.presubmit_canned_checks
     orig = canned.CheckOwners
     with presubmit.canned_check_filter(['CheckOwners']):
       self.assertNotEqual(canned.CheckOwners, orig)
       self.assertEqual(canned.CheckOwners(None, None), [])
@@ skipping 836 matching lines @@
     script_text = (
         'def GetPreferredTrySlaves():\n'
         '  return ["foo,bar"]\n')
     try:
       presubmit.GetTrySlavesExecuter.ExecPresubmitScript(
           script_text, 'path', 'project', None)
       self.fail()
     except presubmit.PresubmitFailure:
       pass
 
+  def testGetTryMastersExecuter(self):
+    self.mox.ReplayAll()
+    change = presubmit.Change(
+        'foo',
+        'Blah Blah\n\nSTORY=http://tracker.com/42\nBUG=boo\n',
+        self.fake_root_dir,
+        None,
+        0,
+        0,
+        None)
+    executer = presubmit.GetTryMastersExecuter()
+    self.assertEqual({}, executer.ExecPresubmitScript('', '', '', change))
+    self.assertEqual({},
+        executer.ExecPresubmitScript('def foo():\n  return\n', '', '', change))
+
+    # bad results
+    empty_master_result = "{'': {}}"
+    starts_with_space_result = "{' m': {}}"
+    empty_slave_result = "{'m': {'': set()}}"
+    not_dict_result1 = "['a']"
+    not_dict_result2 = "{'m': ''}"
+    not_dict_result3 = "{'m': []}"
+    not_set_result = "{'m': {'s': []}}"
+    empty_set_result = "{'m': {'s': set([])}}"
+    
+    for result in (
+        empty_master_result, starts_with_space_result, empty_slave_result,
+        not_dict_result1, not_dict_result2, not_dict_result3, not_set_result,
+        empty_set_result):
+      self.assertRaises(presubmit.PresubmitFailure,
+                        executer.ExecPresubmitScript,
+                        self.presubmit_trymaster % result, '', '', change)
+
+    # good results
+    expected_result = {'m1': {'s1': set(['t1', 't2'])},
+                       'm2': {'s1': set(['defaulttests']),
+                              's2': set(['defaulttests'])}}
+    empty_result1 = {}
+    empty_result2 = {'m': {}}
+    space_in_name_result = {'m r': {'s\tv': set(['t1'])}}
+    for result in (
+        expected_result, empty_result1, empty_result2, space_in_name_result):
+      self.assertEqual(
+          result,
+          executer.ExecPresubmitScript(
+              self.presubmit_trymaster % result, '', '', change))
+
+  def testMergeMasters(self):
+    merge = presubmit._MergeMasters
+    self.assertEqual({}, merge({}, {}))
+    self.assertEqual({'m1': {}}, merge({}, {'m1': {}}))
+    self.assertEqual({'m1': {}}, merge({'m1': {}}, {}))
+    parts = [
+      {'try1.cr': {'win': set(['defaulttests'])}},
+      {'try1.cr': {'linux1': set(['test1'])},
+       'try2.cr': {'linux2': set(['defaulttests'])}},
+      {'try1.cr': {'mac1': set(['defaulttests']),
+                   'mac2': set(['test1', 'test2']),
+                   'linux1': set(['defaulttests'])}},
+    ]
+    expected = {
+      'try1.cr': {'win': set(['defaulttests']),
+                  'linux1': set(['defaulttests', 'test1']),
+                  'mac1': set(['defaulttests']),
+                  'mac2': set(['test1', 'test2'])},
+      'try2.cr': {'linux2': set(['defaulttests'])},
+    }
+    for permutation in itertools.permutations(parts):
+      self.assertEqual(expected, reduce(merge, permutation, {}))
+
+  def testDoGetTryMasters(self):
+    root_text = (self.presubmit_trymaster
+        % '{"t1.cr": {"win": set(["defaulttests"])}}')
+    linux_text = (self.presubmit_trymaster
+        % ('{"t1.cr": {"linux1": set(["t1"])},'
+           ' "t2.cr": {"linux2": set(["defaulttests"])}}'))
+
+    join = presubmit.os.path.join
+    isfile = presubmit.os.path.isfile
+    FileRead = presubmit.gclient_utils.FileRead
+    filename = 'foo.cc'
+    filename_linux = join('linux_only', 'penguin.cc')
+    root_presubmit = join(self.fake_root_dir, 'PRESUBMIT.py')
+    linux_presubmit = join(self.fake_root_dir, 'linux_only', 'PRESUBMIT.py')
+    inherit_path = join(self.fake_root_dir, self._INHERIT_SETTINGS)
+
+    isfile(inherit_path).AndReturn(False)
+    isfile(root_presubmit).AndReturn(True)
+    FileRead(root_presubmit, 'rU').AndReturn(root_text)
+
+    isfile(inherit_path).AndReturn(False)
+    isfile(root_presubmit).AndReturn(True)
+    isfile(linux_presubmit).AndReturn(True)
+    FileRead(root_presubmit, 'rU').AndReturn(root_text)
+    FileRead(linux_presubmit, 'rU').AndReturn(linux_text)
+    self.mox.ReplayAll()
+
+    change = presubmit.Change(
+        'mychange', '', self.fake_root_dir, [], 0, 0, None)
+
+    output = StringIO.StringIO()
+    self.assertEqual({'t1.cr': {'win': ['defaulttests']}},
+                     presubmit.DoGetTryMasters(change, [filename],
+                                               self.fake_root_dir,
+                                               None, None, False, output))
+    output = StringIO.StringIO()
+    expected = {
+      't1.cr': {'win': ['defaulttests'], 'linux1': ['t1']},
+      't2.cr': {'linux2': ['defaulttests']},
+    }
+    self.assertEqual(expected,
+                     presubmit.DoGetTryMasters(change,
+                                               [filename, filename_linux],
+                                               self.fake_root_dir, None, None,
+                                               False, output))
+
   def testMainUnversioned(self):
     # OptParser calls presubmit.os.path.exists and is a pain when mocked.
     self.UnMock(presubmit.os.path, 'exists')
     self.mox.StubOutWithMock(presubmit, 'DoPresubmitChecks')
     self.mox.StubOutWithMock(presubmit, 'ParseFiles')
     presubmit.scm.determine_scm(self.fake_root_dir).AndReturn(None)
     presubmit.ParseFiles(['random_file.txt'], None
         ).AndReturn([('M', 'random_file.txt')])
     output = self.mox.CreateMock(presubmit.PresubmitOutput)
     output.should_continue().AndReturn(False)
@@ skipping 1703 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()