Refactor the way that TestApi works so that it is actually useful.

scripts/slave/unittests/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 json
 import multiprocessing
 import os
 import sys
 import unittest
 from itertools import product, imap
 
 import test_env  # pylint: disable=W0611,F0401
 
-from slave import recipe_api
-from slave import annotated_run
+from slave import recipe_loader
+from slave import recipe_util
 
 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 annotated_run.MODULE_DIRS],
+             for x in recipe_util.MODULE_DIRS()],
     data_suffix=True))()
 
 def covered(fn, *args, **kwargs):
   COVERAGE.start()
   try:
     return fn(*args, **kwargs)
   finally:
     COVERAGE.stop()
 
 RECIPE_MODULES = None
 def init_recipe_modules():
   global RECIPE_MODULES
-  RECIPE_MODULES = covered(recipe_api.load_recipe_modules,
-                           annotated_run.MODULE_DIRS)
+  RECIPE_MODULES = covered(recipe_loader.load_recipe_modules,
+                           recipe_util.MODULE_DIRS())
 
-from slave import recipe_configs_util  # pylint: disable=F0401
+from slave import recipe_config  # pylint: disable=F0401
 
 def get_expect_dir(mod):
   return os.path.join(mod.__path__[0], 'config.expected')
 
 
 def evaluate_configurations(args):
   mod_id, var_assignments = args
   mod = getattr(RECIPE_MODULES, mod_id)
   expect_dir = get_expect_dir(mod)
   ctx = mod.CONFIG_CTX
 
   config_name = None
   try:
     file_name = os.path.join(expect_dir, ctx.TEST_FILE_FORMAT(var_assignments))
     ret = {}
 
     make_item = lambda: covered(ctx.CONFIG_SCHEMA, **var_assignments)
 
     # Try ROOT_CONFIG_ITEM first. If it raises BadConf, then we can skip
     # this config.
     root_item = ctx.ROOT_CONFIG_ITEM
     if root_item:
       config_name = root_item.__name__
       try:
         result = covered(root_item, make_item())
         if result.complete():
           ret[config_name] = result.as_jsonish()
-      except recipe_configs_util.BadConf, e:
+      except recipe_config.BadConf, e:
         return file_name, None, None
 
     for config_name, fn in ctx.CONFIG_ITEMS.iteritems():
       if fn.NO_TEST or fn.IS_ROOT:
         continue
       try:
         result = covered(fn, make_item())
         if result.complete():
           ret[config_name] = result.as_jsonish()
-      except recipe_configs_util.BadConf, e:
+      except recipe_config.BadConf, e:
         ret[config_name] = str(e)
     return file_name, covered(ctx.TEST_NAME_FORMAT, var_assignments), ret
   except Exception, e:
     print 'Caught exception [%s] with args %s: %s' % (e, args, config_name)
 
 
 def train_from_tests(args):
   file_name, _, configuration_results = evaluate_configurations(args)
   if configuration_results is not None:
     if configuration_results:
@@ skipping 132 matching lines @@
       retcode = retcode or 2
 
   if training:
     test_env.print_coverage_warning()
 
   return retcode
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))