Move recipe engine to third_party/recipe_engine.

third_party/recipe_engine/recipe_configs_test.py

 #!/usr/bin/python
 # Copyright 2013 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.
 
 """Provides test coverage for common recipe configurations.
 
 recipe config expectations are located in ../recipe_configs_test/*.expected
 
 In training mode, this will loop over every config item in ../recipe_configs.py
 crossed with every platform, and spit out the as_json() representation to
 ../recipe_configs_test
 
 You must have 100% coverage of ../recipe_configs.py for this test to pass.
 """
 
 import argparse
 import multiprocessing
 import os
 import sys
 import traceback
 from itertools import product, imap
 
-import test_env  # "relative import" pylint: disable=W0403,W0611
-
-from slave import recipe_loader
-from slave import recipe_util
+from . import recipe_loader
+from . import recipe_util
+from . import recipe_config
 
 import coverage
 
 SCRIPT_PATH = os.path.abspath(os.path.dirname(__file__))
 SLAVE_DIR = os.path.abspath(os.path.join(SCRIPT_PATH, os.pardir))
 
-COVERAGE = (lambda: coverage.coverage(
-    include=[os.path.join(x, '*', '*config.py')
-             for x in recipe_util.MODULE_DIRS()],
-    data_file='.recipe_configs_test_coverage', data_suffix=True))()
+UNIVERSE = None
+COVERAGE = None
 
 def covered(fn, *args, **kwargs):
   COVERAGE.start()
   try:
     return fn(*args, **kwargs)
   finally:
     COVERAGE.stop()
 
-UNIVERSE = recipe_loader.RecipeUniverse()
 
 def load_recipe_modules():
   modules = {}
-  for modpath in recipe_loader.loop_over_recipe_modules():
+  for modpath in UNIVERSE.loop_over_recipe_modules():
     # That's right, we're using the path as the local name! The local
     # name really could be anything unique, we don't use it.
     modules[modpath] = UNIVERSE.load(recipe_loader.PathDependency(
-        modpath, local_name=modpath, base_path=os.curdir))
+        modpath, local_name=modpath, base_path=os.curdir, universe=UNIVERSE))
   return modules
 
 
 RECIPE_MODULES = None
 def init_recipe_modules():
   global RECIPE_MODULES
   RECIPE_MODULES = covered(load_recipe_modules)
 
-from slave import recipe_config  # pylint: disable=F0401
-
 
 def evaluate_configurations(args):
   mod_id, var_assignments = args
   mod = RECIPE_MODULES[mod_id]
   ctx = mod.CONFIG_CTX
 
   config_name = None
   try:
     make_item = lambda: covered(ctx.CONFIG_SCHEMA, **var_assignments)
 
@@ skipping 57 matching lines @@
   pool = multiprocessing.Pool(initializer=multiprocessing_init)
   try:
     return pool.map_async(fn, combination_generator).get(999999)
   finally:
     # necessary so that the subprocesses will write out their coverage due to
     # the hack in multiprocessing_init()
     pool.close()
     pool.join()
 
 
-def main():
+def main(universe):
+  global UNIVERSE
+  global COVERAGE
+  UNIVERSE = universe
+  COVERAGE = coverage.coverage(
+    include=[os.path.join(x, '*', '*config.py')
+             for x in UNIVERSE.module_dirs],
+    data_file='.recipe_configs_test_coverage', data_suffix=True)
   COVERAGE.erase()
   init_recipe_modules()
 
   success = all(coverage_parallel_map(evaluate_configurations))
 
   COVERAGE.combine()
   total_covered = COVERAGE.report()
   all_covered = total_covered == 100.0
 
   if not success:
     print 'FATAL: Some recipe configuration(s) failed'
   if not all_covered:
     print 'FATAL: Recipes configs are not at 100% coverage.'
 
   return 1 if (not success or not all_covered) else 0
 
 
 if __name__ == '__main__':
   sys.exit(main())