'recipes.py isolate' command to build an isolate of the current package's toolchain

unittests/package_setup_test.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
+import json
 import os
+import re
 import shutil
 import subprocess
 import tempfile
 import unittest
 
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 class RecipeRepo(object):
   def __init__(self):
     self._root = tempfile.mkdtemp()
@@ skipping 21 matching lines @@
       fh.write(contents)
 
   def make_module(self, name, init_contents, api_contents):
     module_root = os.path.join(self._modules_dir, name)
     os.mkdir(module_root)
     with open(os.path.join(module_root, '__init__.py'), 'w') as fh:
       fh.write(init_contents)
     with open(os.path.join(module_root, 'api.py'), 'w') as fh:
       fh.write(api_contents)
 
-  @property
-  def recipes_cmd(self):
-    return [
+  def make_file(self, relpath, contents):
+    dirname = os.path.join(self._root, os.path.dirname(relpath))
+    if dirname and not os.path.exists(dirname):
+      os.makedirs(dirname)
+    with open(os.path.join(self._root, relpath), 'w') as fh:
+      fh.write(contents)
+
+  def recipes_cmd(self, package_override=True):
+    cmd = [
         os.path.join(ROOT_DIR, 'recipes.py'),

[M-A Ruel, 2016/01/09 00:52:00]

sys.executable,

         '--package', self._recipes_cfg,
-        '-O', 'recipe_engine=%s' % ROOT_DIR]
+    ]
+    if package_override:
+      cmd += ['-O', 'recipe_engine=%s' % ROOT_DIR]
+    return cmd
 
   def __enter__(self):
     return self
 
   def __exit__(self, *_):
     shutil.rmtree(self._root)
 
-class ErrorsTest(unittest.TestCase):
-  def _test_cmd(self, repo, cmd, asserts, retcode=0):
+class PackageSetupTest(unittest.TestCase):
+  def _test_cmd(self, repo, cmd, asserts, retcode=0, package_override=True):
     subp = subprocess.Popen(
-        repo.recipes_cmd + cmd,
+        repo.recipes_cmd(package_override=package_override) + cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE)
     stdout, stderr = subp.communicate()
     if asserts:
       asserts(stdout, stderr)
     self.assertEqual(subp.returncode, retcode)
 
   def test_missing_dependency(self):
     with RecipeRepo() as repo:
       repo.make_recipe('foo', """
 DEPS = ['aint_no_thang']
 """)
       subp = subprocess.Popen(
-          repo.recipes_cmd + ['run', 'foo'],
+          repo.recipes_cmd() + ['run', 'foo'],
           stdout=subprocess.PIPE)
       stdout, _ = subp.communicate()
       self.assertRegexpMatches(stdout,
         r'aint_no_thang does not exist[^\n]*while loading recipe foo')
       self.assertEqual(subp.returncode, 2)
 
   def test_missing_module_dependency(self):
     with RecipeRepo() as repo:
       repo.make_recipe('foo', 'DEPS = ["le_module"]')
       repo.make_module('le_module', 'DEPS = ["love"]', '')
       subp = subprocess.Popen(
-          repo.recipes_cmd + ['run', 'foo'],
+          repo.recipes_cmd() + ['run', 'foo'],
           stdout=subprocess.PIPE)
       stdout, _ = subp.communicate()
       self.assertRegexpMatches(stdout,
         r'love does not exist[^\n]*'
         r'while loading recipe module \S*le_module[^\n]*'
         r'while loading recipe foo')
       self.assertEqual(subp.returncode, 2)
 
   def test_no_such_recipe(self):
     with RecipeRepo() as repo:
       subp = subprocess.Popen(
-          repo.recipes_cmd + ['run', 'nooope'],
+          repo.recipes_cmd() + ['run', 'nooope'],
           stdout=subprocess.PIPE)
       stdout, _ = subp.communicate()
       self.assertRegexpMatches(stdout, r'No such recipe: nooope')
       self.assertEqual(subp.returncode, 2)
 
   def test_syntax_error(self):
     with RecipeRepo() as repo:
       repo.make_recipe('foo', """
 DEPS = [ (sic)
 """)
@@ skipping 65 matching lines @@
   pass
 
 def GenTests(api):
   yield api.test('basic') + api.expect_exception('AssertionError')
 """)
       self._test_cmd(repo, ['simulation_test', 'train', 'unconsumed_assertion'],
         asserts=lambda stdout, stderr: self.assertRegexpMatches(
             stdout + stderr, 'Unconsumed'),
         retcode=1)
 
+  def test_isolate(self):
+    def check_isolate_form(stdout, stderr):
+      spec = json.loads(stdout)
+      self.assertEqual(set(spec.keys()), set(['variables']))
+      self.assertEqual(set(spec['variables']),
+                       set(['command', 'files']))
+      files = list(spec['variables']['files'])
+      self.assertTrue(not any( i.endswith('.pyc') for i in files ))
+
+      engine_files, nonengine_files = _partition(
+          files, lambda i: re.match(r'\.recipe_deps/recipe_engine/.*', i))
+      self.assertTrue(engine_files)
+
+      self.assertEqual(
+          set(nonengine_files),
+          set(['infra/config/recipes.cfg',
+               'recipes.py',
+               'recipes.extra',
+               'recipes/some_recipe.py',
+               'recipe_modules/some_module/__init__.py',
+               'recipe_modules/some_module/api.py',
+               'supporting/file.txt']))
+
+      self.assertEqual(
+          spec['variables']['command'],
+          ['python', '.recipe_deps/recipe_engine/recipes.py',
+           '--package', 'infra/config/recipes.cfg',
+           '--no-fetch'])
+
+    with RecipeRepo() as repo:
+      repo.make_recipe('some_recipe', '')
+      repo.make_module('some_module', '', '')
+      repo.make_file(os.path.join('supporting', 'file.txt'), 'yay')
+      repo.make_file(os.path.join('unsupporting', 'file.txt'), 'nay')
+      repo.make_file(os.path.join('recipes.extra'), 'supporting')
+      self._test_cmd(repo,
+          ['isolate'], asserts=check_isolate_form, package_override=False)
+
+def _partition(items, pred):
+  return ([ item for item in items if pred(item) ],
+          [ item for item in items if not pred(item) ])
+
+
 if __name__ == '__main__':
   unittest.main()