Enforce passing cwd via context rather then api.step kwargs

recipe_modules/step/api.py

 # Copyright 2013 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.
 
 import contextlib
 import datetime
 
 from recipe_engine import recipe_api
 
 
@@ skipping 59 matching lines @@
           new_step_text = result.json.output['step_text']
           api.step.active_result.presentation.step_text = new_step_text
     """
     return self.step_client.previous_step_result()
 
   @property
   def context(self):
     """ See recipe_api.py for docs. """
     return recipe_api.context
 
+  def get_context(self):
+    return recipe_api._STEP_CONTEXT
+
   @contextlib.contextmanager
   def nest(self, name):
     """Nest is the high-level interface to annotated hierarchical steps.
 
     Calling
 
         with api.step.nest(<name>):
           ...
 
     will generate a dummy step and implicitly create a new context (as
     above); the dummy step will govern annotation emission, while the implicit
     context will propagate the dummy step's name to subordinate steps.
     """
     step_result = self(name, [])
     context_dict = {'name': name, 'nest_level': 1}
     with self.context(context_dict):
       yield step_result
 
   @property
   def defer_results(self):
     """ See recipe_api.py for docs. """
     return recipe_api.defer_results
 
   def __call__(self, name, cmd, ok_ret=None, infra_step=False, wrapper=(),
-               timeout=None, cwd=None, env=None, allow_subannotations=None,
+               timeout=None, env=None, allow_subannotations=None,
                trigger_specs=None, stdout=None, stderr=None, stdin=None,
                step_test_data=None):
     """Returns a step dictionary which is compatible with annotator.py.
 
     Args:
       name (string): The name of this step.
       cmd (list of strings): in the style of subprocess.Popen or None to create
         a no-op fake step.
       ok_ret (tuple or set of ints, str): allowed return codes. Any unexpected
         return codes will cause an exception to be thrown. If you pass in the
@@ skipping 19 matching lines @@
       stdin: Placeholder to read step stdin from.
       step_test_data (func -> recipe_test_api.StepTestData): A factory which
           returns a StepTestData object that will be used as the default test
           data for this step. The recipe author can override/augment this object
           in the GenTests function.
 
     Returns:
       Opaque step object produced and understood by recipe engine.
     """
     kwargs = {}
-    if cwd:
-      kwargs['cwd'] = cwd
     if env:
       kwargs['env'] = env
     if allow_subannotations is not None:
       kwargs['allow_subannotations'] = allow_subannotations
     if trigger_specs:
       kwargs['trigger_specs'] = trigger_specs
     if stdout:
       kwargs['stdout'] = stdout
     if stderr:
       kwargs['stderr'] = stderr
     if stdin:
       kwargs['stdin'] = stdin
     if step_test_data:
       kwargs['step_test_data'] = step_test_data
     assert cmd is None or isinstance(cmd, list)
     if not ok_ret:
       ok_ret = {0}
     if ok_ret in ('any', 'all'):
       ok_ret = set(range(-256, 256))
 
     if cmd is not None:
       command = list(wrapper)
       command += cmd
       kwargs['cmd'] = command
 
     kwargs['timeout'] = timeout
     kwargs['ok_ret'] = ok_ret
 
     # Obtain information from composite step parent.
-    compositor = recipe_api._STEP_CONTEXT
+    compositor = self.get_context()
 
     # Calculate our full step name. If a step already has that name, add an
     # index to the end of it.
     #
     # Note that another step could exist with that index already added to it
     # by the user. If this happens, we'll continue appending indexes until we
     # have a unique step name.
     while True:
       full_name = compositor.get_with_context('name', name)
       if full_name not in self._seen_steps:
@@ skipping 14 matching lines @@
     kwargs['base_name'] = name
 
     schema = self.make_config()
     schema.set_val(kwargs)
     return self.run_from_dict(schema.as_jsonish())
 
   # TODO(martiniss) delete, and make generator_script use **kwargs on step()
   @recipe_api.composite_step
   def run_from_dict(self, dct):
     return self.step_client.run_step(dct)