autoninja: add simple test

This is to prevent revert like https://crrev.com/c/3607513

Bug: 1317620
Change-Id: I6ab7aba5f92719bd573d22d90358f58e48aeb10c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/tools/depot_tools/+/3607514
Reviewed-by: Bruce Dawson <brucedawson@chromium.org>
Reviewed-by: Gavin Mak <gavinmak@google.com>
Commit-Queue: Takuto Ikuta <tikuta@chromium.org>

PRESUBMIT.py

@@ -124,7 +124,10 @@ def CheckUnitTestsOnCommit(input_api, output_api):
       'recipes_test.py',
   ]
 
-  py3_only_tests = ['ninjalog_uploader_test.py']
+  py3_only_tests = [
+      'autoninja_test.py',
+      'ninjalog_uploader_test.py',
+  ]
 
   tests = input_api.canned_checks.GetUnitTestsInDirectory(
       input_api,

autoninja.py

@@ -21,22 +21,24 @@ import sys
 
 SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
 
+
+def main(args):
   # The -t tools are incompatible with -j
   t_specified = False
   j_specified = False
   offline = False
   output_dir = '.'
-input_args = sys.argv
+  input_args = args
   # On Windows the autoninja.bat script passes along the arguments enclosed in
   # double quotes. This prevents multiple levels of parsing of the special '^'
-# characters needed when compiling a single file but means that this script gets
-# called with a single argument containing all of the actual arguments,
+  # characters needed when compiling a single file but means that this script
+  # gets called with a single argument containing all of the actual arguments,
   # separated by spaces. When this case is detected we need to do argument
   # splitting ourselves. This means that arguments containing actual spaces are
   # not supported by autoninja, but that is not a real limitation.
-if (sys.platform.startswith('win') and len(sys.argv) == 2 and
-    input_args[1].count(' ') > 0):
-  input_args = sys.argv[:1] + sys.argv[1].split()
+  if (sys.platform.startswith('win') and len(args) == 2
+      and input_args[1].count(' ') > 0):
+    input_args = args[:1] + args[1].split()
 
   # Ninja uses getopt_long, which allow to intermix non-option arguments.
   # To leave non supported parameters untouched, we do not use getopt.
@@ -68,10 +70,10 @@ use_remoteexec = False
   # they exist and using remoteexec, then automatically call bootstrap to start
   # reproxy.  This works under the current assumption that the output
   # directory is two levels up from chromium/src.
-reclient_bin_dir = os.path.join(
-  output_dir, '..', '..', 'buildtools', 'reclient')
-reclient_cfg = os.path.join(
-  output_dir, '..', '..', 'buildtools', 'reclient_cfgs', 'reproxy.cfg')
+  reclient_bin_dir = os.path.join(output_dir, '..', '..', 'buildtools',
+                                  'reclient')
+  reclient_cfg = os.path.join(output_dir, '..', '..', 'buildtools',
+                              'reclient_cfgs', 'reproxy.cfg')
 
   # Attempt to auto-detect remote build acceleration. We support gn-based
   # builds, where we look for args.gn in the build tree, and cmake-based builds
@@ -109,13 +111,14 @@ else:
               use_goma = True
               break
 
-# If GOMA_DISABLED is set to "true", "t", "yes", "y", or "1" (case-insensitive)
-# then gomacc will use the local compiler instead of doing a goma compile. This
-# is convenient if you want to briefly disable goma. It avoids having to rebuild
-# the world when transitioning between goma/non-goma builds. However, it is not
-# as fast as doing a "normal" non-goma build because an extra process is created
-# for each compile step. Checking this environment variable ensures that
-# autoninja uses an appropriate -j value in this situation.
+  # If GOMA_DISABLED is set to "true", "t", "yes", "y", or "1"
+  # (case-insensitive) then gomacc will use the local compiler instead of doing
+  # a goma compile. This is convenient if you want to briefly disable goma. It
+  # avoids having to rebuild the world when transitioning between goma/non-goma
+  # builds. However, it is not as fast as doing a "normal" non-goma build
+  # because an extra process is created for each compile step. Checking this
+  # environment variable ensures that autoninja uses an appropriate -j value in
+  # this situation.
   goma_disabled_env = os.environ.get('GOMA_DISABLED', '0').lower()
   if offline or goma_disabled_env in ['true', 't', 'yes', 'y', '1']:
     use_goma = False
@@ -127,8 +130,10 @@ if use_goma:
     # Don't invoke gomacc if it doesn't exist.
     if os.path.exists(gomacc_path):
       # Check to make sure that goma is running. If not, don't start the build.
-    status = subprocess.call([gomacc_path, 'port'], stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE, shell=False)
+      status = subprocess.call([gomacc_path, 'port'],
+                               stdout=subprocess.PIPE,
+                               stderr=subprocess.PIPE,
+                               shell=False)
       if status == 1:
         print('Goma is not running. Use "goma_ctl ensure_start" to start it.',
               file=sys.stderr)
@@ -154,7 +159,6 @@ if (sys.platform.startswith('linux')
     # ionice -c 3 is IO priority IDLE
     prefix_args = ['nice'] + ['-10']
 
-
   # Use absolute path for ninja path,
   # or fail to execute ninja if depot_tools is not in PATH.
   args = prefix_args + [ninja_exe_path] + input_args[1:]
@@ -167,7 +171,8 @@ if not j_specified and not t_specified:
       j_value = num_cores * core_multiplier
 
       if sys.platform.startswith('win'):
-      # On windows, j value higher than 1000 does not improve build performance.
+        # On windows, j value higher than 1000 does not improve build
+        # performance.
         j_value = min(j_value, 1000)
       elif sys.platform == 'darwin':
         # On Mac, j value higher than 500 causes 'Too many open files' error
@@ -201,9 +206,9 @@ if (not offline and use_remoteexec and os.path.exists(reclient_bin_dir)
       and os.path.exists(reclient_cfg)):
     bootstrap = os.path.join(reclient_bin_dir, 'bootstrap')
     setup_args = [
-    bootstrap,
-    '--cfg=' + reclient_cfg,
-    '--re_proxy=' + os.path.join(reclient_bin_dir, 'reproxy')]
+        bootstrap, '--cfg=' + reclient_cfg,
+        '--re_proxy=' + os.path.join(reclient_bin_dir, 'reproxy')
+    ]
 
     teardown_args = [bootstrap, '--cfg=' + reclient_cfg, '--shutdown']
 
@@ -213,6 +218,10 @@ if (not offline and use_remoteexec and os.path.exists(reclient_bin_dir)
   if offline and not sys.platform.startswith('win'):
     # Tell goma or reclient to do local compiles. On Windows these environment
     # variables are set by the wrapper batch file.
-  print('RBE_remote_disabled=1 GOMA_DISABLED=1 ' + ' '.join(args))
-else:
-  print(' '.join(args))
+    return 'RBE_remote_disabled=1 GOMA_DISABLED=1 ' + ' '.join(args)
+
+  return ' '.join(args)
+
+
+if __name__ == '__main__':
+  print(main(sys.argv))

tests/OWNERS

@@ -1 +1,3 @@
+per-file autoninja_test.py=brucedawson@chromium.org
+per-file autoninja_test.py=tikuta@chromium.org
 per-file ninjalog_uploader_test.py=tikuta@chromium.org

tests/autoninja_test.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# Copyright (c) 2022 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.
+
+import multiprocessing
+import os
+import os.path
+import sys
+import unittest
+import unittest.mock
+
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, ROOT_DIR)
+
+import autoninja
+
+
+class AutoninjaTest(unittest.TestCase):
+  def test_autoninja(self):
+    autoninja.main([])
+
+  def test_autoninja_goma(self):
+    with unittest.mock.patch(
+        'os.path.exists',
+        return_value=True) as mock_exists, unittest.mock.patch(
+            'autoninja.open', unittest.mock.mock_open(
+                read_data='use_goma=true')) as mock_open, unittest.mock.patch(
+                    'subprocess.call', return_value=0):
+      args = autoninja.main([]).split()
+      mock_exists.assert_called()
+      mock_open.assert_called_once()
+
+    self.assertIn('-j', args)
+    parallel_j = int(args[args.index('-j') + 1])
+    self.assertGreater(parallel_j, multiprocessing.cpu_count())
+
+
+if __name__ == '__main__':
+  unittest.main()