[context] fix treatment of None in env.

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.
@@ skipping 27 matching lines @@
 
 def check_type(name, var, expect):
   if not isinstance(var, expect):  # pragma: no cover
     raise TypeError('%s is not %s: %r (%s)' % (
       name, expect.__name__, var, type(var).__name__))
 
 
 _EnvPathComponent = collections.namedtuple('_EnvPathComponent', (
     'paths',))
 
+# prefixes is a list of strings
+# value is either a string or None
 _EnvValue = collections.namedtuple('_EnvValue', (
-    'prefixes', 'str'))
+    'prefixes', 'value'))
 
 
 class ContextApi(RecipeApi):
 
   # TODO(iannucci): move implementation of these data directly into this class.
   def __init__(self, **kwargs):
     super(RecipeApi, self).__init__(**kwargs)
 
     self._cwd = [None]
     self._env = [{}]
@@ skipping 84 matching lines @@
       else:
         self._name_prefix.append(name_prefix)
       to_pop.append(self._name_prefix)
 
     if env is not None and env != {}:
       check_type('env', env, dict)
       # we hit _env directly to avoid an extra copy.
       new = dict(self._env[-1])
       for k, v in env.iteritems():
         k = str(k)
-        ev = new.get(k)
-        if ev is None:
-          ev = _EnvValue(prefixes=(), str=None)
-        if v is not None:
+        if v is None:
+          ev = _EnvValue(prefixes=(), value=None)
+        else:
+          ev = new.get(k, _EnvValue(prefixes=(), value=''))
           if isinstance(v, _EnvPathComponent):
             ev = ev._replace(prefixes=v.paths+ev.prefixes)
           else:
             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,))
-            ev = ev._replace(str=v)
+            ev = ev._replace(value=v)
         new[k] = ev
       self._env.append(new)
       to_pop.append(self._env)
 
     try:
       yield
     finally:
       for p in to_pop:
         p.pop()
 
@@ skipping 16 matching lines @@
     done with properties.
 
     Returns (dict) - The env-key -> value mapping of current environment
       modifications.
     """
     # TODO(iannucci): store env in an immutable way to avoid excessive copies.
     # TODO(iannucci): handle case-insensitive keys on windows
     def parts(ev):
       for p in ev.prefixes:
         yield str(p)
-      if ev.str is not None:
-        yield ev.str
+      if ev.value:
+        yield ev.value
 
-    return {k: self.m.path.pathsep.join(parts(ev))
-            for k, ev in self._env[-1].iteritems()}
+    ret = {}
+    for k, ev in self._env[-1].iteritems():
+      if ev.value is None:
+        ret[k] = None
+      else:
+        ret[k] = self.m.path.pathsep.join(parts(ev))
+
+    return ret
 
   @property
   def infra_step(self):
     """Returns the current value of the infra_step setting.
 
     Returns (bool) - True iff steps are currently considered infra steps.
     """
     return self._infra_step[-1]
 
   @property
@@ skipping 23 matching lines @@
     Each path in paths is added, in order, as a prefix to the environment
     variable, delimited by the OS path separator. This can be used for
     easy manipulation of path environment variables such as PATH and PYTHONPATH.
 
     Args:
       paths (...Path): The list of paths to prefix.
     """
     for i, path in enumerate(paths):
         check_type('path element %d' % (i,), path, Path)
     return _EnvPathComponent(paths=paths)