[step_runner] run _merge_envs in simulation too.

recipe_modules/context/api.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.
 
 """The context module provides APIs for manipulating a few pieces of 'ambient'
 data that affect how steps are run:
   cwd - The current working directory.
   env - The environment variables.
   infra_step - Whether or not failures should be treated as infrastructure
     failures vs. normal failures.
   name_prefix - A prefix for all step names.
   nest_level - An indicator for the UI of how deeply to nest steps.
 
 The values here are all scoped using Python's `with` statement; there's no
 mechanism to make an open-ended adjustment to these values (i.e. there's no way
 to change the cwd permanently for a recipe, except by surrounding the entire
 recipe with a with statement). This is done to avoid the surprises that
 typically arise with things like os.environ or os.chdir in a normal python
 program.
 
 Example:
   with api.context(cwd=api.path['start_dir'].join('subdir')):
     # this step is run inside of the subdir directory.
     api.step("cat subdir/foo", ['cat', './foo'])
 """
 
 
+import collections
 import copy
 
 from contextlib import contextmanager
 
 from recipe_engine import recipe_api
 from recipe_engine.config_types import Path
 from recipe_engine.recipe_api import context, RecipeApi
 
 
 def check_type(name, var, expect):
@@ skipping 92 matching lines @@
       kwargs['nest_level'] = 1
 
     if name_prefix is not None:
       check_type('name_prefix', name_prefix, str)
       kwargs['name'] = name_prefix
 
     if env is not None and env != {}:
       check_type('env', env, dict)
       # strify everything except None in the env to allow for ints, Paths, etc.
       # None has special meaning (i.e. "delete this env key")
-      kwargs['env'] = {str(k): (str(v) if v is not None else None)
-                       for k, v in env.iteritems()}
+      new_env = {}
+      for k, v in env.iteritems():
+        k = str(k)
+        if v is not None:
+          v = str(v)
+          try:
+            # This odd little piece of code does the following:
+            #   * add a bogus dictionary format %(foo)s to v. This forces % into
+            #     'dictionary lookup' mode
+            #   * format the result with a defaultdict. This allows all
+            #     `%(key)s` format lookups to succeed, but any sequential `%s`
+            #     lookups to fail.
+            # If the string contains any accidental sequential lookups, this
+            # will raise an exception. If not, then this is a pluasible format
+            # string.
+            ('%(foo)s'+v) % collections.defaultdict(str)
+          except Exception:
+            raise ValueError(('Invalid %%-formatting parameter in envvar, '
+                              'only %%(ENVVAR)s allowed: %r') % (v,))
+        new_env[k] = v
+      kwargs['env'] = new_env
 
     if not kwargs:
       yield
     else:
       with context(kwargs):
         yield
 
   @property
   def cwd(self):
     """Returns the current working directory that steps will run in.
@@ skipping 39 matching lines @@
   def nest_level(self):
     """Returns the current 'nesting' level.
 
     Note: This api is low-level, and you should always prefer to use
     `api.step.nest`. This api is included for completeness and documentation
     purposes.
 
     Returns (int) - The current nesting level.
     """
     return recipe_api._STEP_CONTEXT.get('nest_level', 0)