[recipes.py] move test arg parsing to its module

recipe_engine/test.py

 # Copyright 2017 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 from __future__ import print_function
 
 import bdb
 import cStringIO
 import contextlib
 import copy
-import coverage
 import datetime
 import difflib
 import fnmatch
 import functools
 import json
 import multiprocessing
 import os
 import pdb
 import pprint
 import re
 import shutil
 import signal
 import sys
 import tempfile
 import traceback
 
-from google.protobuf import json_format
-
 from . import checker
 from . import config_types
 from . import loader
+from . import package
 from . import run
 from . import step_runner
 from . import stream
+
+from . import env
+
+from google.protobuf import json_format
+
 from . import test_result_pb2
 
 from . import env
 
 import argparse  # this is vendored
 
 
 # These variables must be set in the dynamic scope of the functions in this
 # file.  We do this instead of passing because they're not picklable, and
 # that's required by multiprocessing.
@@ skipping 15 matching lines @@
 
 
 class PostProcessError(ValueError):
   """Exception raised when any of the post-process hooks fails."""
   pass
 
 
 @contextlib.contextmanager
 def coverage_context(include=None, enable=True):
   """Context manager that records coverage data."""
+  # TODO(iannucci): once we're always bootstrapping, move this to the top.
+  import coverage
   c = coverage.coverage(config_file=False, include=include)
 
   if not enable:
     yield c
     return
 
   # Sometimes our strict include lists will result in a run
   # not adding any coverage info. That's okay, avoid output spam.
   c._warn_no_data = False
 
@@ skipping 257 matching lines @@
             v['name'] = k
         raw_expectations = rslt
 
     # empty means drop expectation
     result_data = raw_expectations.values() if raw_expectations else None
     return (result_data, failed_checks, coverage_data)
 
 
 def get_tests(test_filter=None):
   """Returns a list of tests for current recipe package."""
+  # TODO(iannucci): once we're always bootstrapping, move this to the top.
+  import coverage
+
   tests = []
   coverage_data = coverage.CoverageData()
 
   all_modules = set(_UNIVERSE_VIEW.loop_over_recipe_modules())
   covered_modules = set()
 
   base_covers = []
 
   coverage_include = os.path.join(_UNIVERSE_VIEW.module_dir, '*', '*.py')
   for module in all_modules:
@@ skipping 179 matching lines @@
   # Exclude recipe engine files from simulation test coverage. Simulation tests
   # should cover "user space" recipe code (recipes and modules), not the engine.
   # The engine is covered by unit tests, not simulation tests.
   omit.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '*'))
 
   return omit
 
 
 def report_coverage_version():
   """Prints info about coverage module (for debugging)."""
+  # TODO(iannucci): once we're always bootstrapping, move this to the top.
+  import coverage
+
   print('Using coverage %s from %r' % (coverage.__version__, coverage.__file__))
 
 
 @contextlib.contextmanager
 def scoped_override(obj, attr, override):
   """Sets |obj|.|attr| to |override| in scope of the context manager."""
   orig = getattr(obj, attr)
   setattr(obj, attr, override)
   yield
   setattr(obj, attr, orig)
@@ skipping 47 matching lines @@
           continue
         full_subentry = os.path.join(full_entry, subentry)
         collected_expectations.add(full_subentry)
     elif entry.endswith('.json'):
       collected_expectations.add(full_entry)
   return collected_expectations
 
 
 def run_run(test_filter, jobs=None, debug=False, train=False, json_file=None):
   """Implementation of the 'run' command."""
+  # TODO(iannucci): once we're always bootstrapping, move this to the top.
+  import coverage
+
   start_time = datetime.datetime.now()
 
   report_coverage_version()
 
   rc = 0
   results_proto = test_result_pb2.TestResult()
   results_proto.version = 1
   results_proto.valid = True
 
   tests, coverage_data, uncovered_modules = get_tests(test_filter)
@@ skipping 272 matching lines @@
       help='glob filter for the tests to run; '
            'can be specified multiple times; '
            'the globs have the form of '
            '`<recipe_name_glob>[.<test_name_glob>]`. If `.<test_name_glob>` '
            'is omitted, it is implied to be `*.*`, i.e. any recipe with this '
            'prefix and all tests.)')
 
   return parser.parse_args(args)
 
 
-def main(universe_view, raw_args, engine_flags):
+def add_subparser(parser):
+  # TODO(iannucci): add actual subparsers here, make main argparse parser to do
+  # full commandline parsing to allow --help to work correctly.
+  test_p = parser.add_parser(
+    'test',
+    description='Generate or check expectations by simulation')
+  test_p.add_argument('args', nargs=argparse.REMAINDER)
+
+  def postprocess_func(_parser, args):
+    # Auto-enable bootstrap for test command invocations (necessary to get
+    # recent enough version of coverage package), unless explicitly disabled.
+    if args.use_bootstrap is None:
+      args.use_bootstrap = True
+
+  test_p.set_defaults(command='test', func=main,
+                      postprocess_func=postprocess_func)
+
+
+def main(package_deps, args):
   """Runs simulation tests on a given repo of recipes.
 
   Args:
     universe_view: an UniverseView object to operate on
     raw_args: command line arguments to the 'test' command
     engine_flags: recipe engine command-line flags
   Returns:
     Exit code
   """
+  universe = loader.RecipeUniverse(package_deps, args.package)
+  universe_view = loader.UniverseView(universe, package_deps.root_package)
+  raw_args=args.args
+  engine_flags=args.operational_args.engine_flags
+
+  # Prevent flakiness caused by stale pyc files.
+  package.cleanup_pyc(package_deps.root_package.recipes_dir)
+
   global _UNIVERSE_VIEW
   _UNIVERSE_VIEW = universe_view
   global _ENGINE_FLAGS
   _ENGINE_FLAGS = engine_flags
 
   args = parse_args(raw_args)
   return args.func(args)