[autoroll] make autoroller propagate changes to recipes.py.

unittests/autoroll_test.py

 #!/usr/bin/env python
 # Copyright 2016 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 json
 import os
 import subprocess
 import sys
 import unittest
 
 import repo_test_util
 
 
 class TestAutoroll(repo_test_util.RepoTest):
   def run_roll(self, repo, *args):
     """Runs the autoroll command and returns JSON.
     Does not commit the resulting roll.
     """
     with repo_test_util.in_directory(repo['root']), \
         repo_test_util.temporary_file() as tempfile_path:
       subprocess.check_output([
-          sys.executable, self._recipe_tool,
-          '--package', os.path.join(
-              repo['root'], 'infra', 'config', 'recipes.cfg'),
-          '--use-bootstrap',
-          'autoroll',
-          '--output-json', tempfile_path
-      ] + list(args), stderr=subprocess.STDOUT)
+        sys.executable, self._recipe_tool,
+        '--package', os.path.join(
+          repo['root'], 'infra', 'config', 'recipes.cfg'),
+        '--use-bootstrap',
+        'autoroll',
+        '--output-json', tempfile_path
+      ] + list(args) , stderr=subprocess.STDOUT)
       with open(tempfile_path) as f:
         return json.load(f)
 
   def test_empty(self):
     """Tests the scenario where there are no roll candidates.
     """
     repos = self.repo_setup({
         'a': [],
     })
 
     roll_result = self.run_roll(repos['a'])
     self.assertFalse(roll_result['success'])
     self.assertEquals([], roll_result['roll_details'])
     self.assertEquals([], roll_result['rejected_candidates_details'])
 
+  def test_bogus_recipes_py(self):
+    repos = self.repo_setup({
+        'a': [],
+        'b': ['a'],
+    })
+    self.get_package_spec(repos['b'])
+
+    # Create a new commit in the A repo.
+    self.commit_in_repo(repos['a'], message='c1')
+
+    # goof up recipes.py in B repo.
+    with open(os.path.join(repos['b']['root'], 'recipes.py'), 'wb') as f:
+      print >> f, "Hey! This isn't even a python script."
+    self.commit_in_repo(repos['b'], message='goof it up!')
+
+    with self.assertRaises(subprocess.CalledProcessError) as ex:
+      self.run_roll(repos['b'])
+    self.assertIn('unable to find configuration section', ex.exception.output)
+
+
   def test_trivial(self):
     """Tests the simplest trivial (i.e. no expectation changes) roll scenario.
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
     })
     b_package_spec = self.get_package_spec(repos['b'])
 
     # Create a new commit in the A repo.
@@ skipping 28 matching lines @@
   def test_nontrivial(self):
     """Tests the simplest nontrivial (i.e. expectation changes) roll scenario.
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
     })
     b_package_spec = self.get_package_spec(repos['b'])
 
     # Set up a recipe in repo B depending on a module in repo A.
-    a_c1 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
+    self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
-    b_c1 = self.update_recipe(
+    self.update_recipe(
         repos['b'], 'b_recipe', ['a/a_module'], [('a_module', 'foo')])
 
     # Change API of the recipe module in a way that's compatible,
     # but changes expectations.
     a_c2 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['baz']})
 
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertFalse(roll_result['trivial'])
 
@@ skipping 25 matching lines @@
   def test_failure(self):
     """Tests the simplest scenario where an automated roll is not possible
     because of incompatible API changes.
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
     })
 
     # Set up a recipe in repo B depending on a module in repo A.
-    a_c1 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
+    self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
-    b_c1 = self.update_recipe(
+    self.update_recipe(
         repos['b'], 'b_recipe', ['a/a_module'], [('a_module', 'foo')])
 
     # Change API of the recipe module in an incompatible way.
-    a_c2 = self.update_recipe_module(repos['a'], 'a_module', {'baz': ['baz']})
+    self.update_recipe_module(repos['a'], 'a_module', {'baz': ['baz']})
 
     roll_result = self.run_roll(repos['b'])
     self.assertFalse(roll_result['success'])
 
   def test_jump_over_failure(self):
     """Tests whether the roller considers pulling more commits to make
     the roll succeed, when earlier ones have incompatible API changes
     fixed later.
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
     })
     b_package_spec = self.get_package_spec(repos['b'])
 
     # Set up a recipe in repo B depending on a module in repo A.
-    a_c1 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
+    self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
-    b_c1 = self.update_recipe(
+    self.update_recipe(
         repos['b'], 'b_recipe', ['a/a_module'], [('a_module', 'foo')])
 
     # Change API of the recipe module in an incompatible way.
     a_c2 = self.update_recipe_module(repos['a'], 'a_module', {'baz': ['baz']})
 
     # Restore compatibility, but change expectations.
     a_c3 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['baz']})
 
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
@@ skipping 34 matching lines @@
     """Test that with several nontrivial rolls possible, the minimal one
     is picked.
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
     })
     b_package_spec = self.get_package_spec(repos['b'])
 
     # Set up a recipe in repo B depending on a module in repo A.
-    a_c1 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
+    self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
-    b_c1 = self.update_recipe(
+    self.update_recipe(
         repos['b'], 'b_recipe', ['a/a_module'], [('a_module', 'foo')])
 
     # Change API of the recipe module in an incompatible way.
     a_c2 = self.update_recipe_module(repos['a'], 'a_module', {'baz': ['baz']})
 
     # Restore compatibility, but change expectations.
     a_c3 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['baz']})
 
     # Create another change that would result in a nontrivial roll,
     # which should not be picked - nontrivial rolls should be minimal.
-    a_c4 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bam']})
+    self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bam']})
 
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertFalse(roll_result['trivial'])
 
     expected_picked_roll = {
         'commit_infos': {
             'a': [
                 {
                     'author': a_c2['author_email'],
@@ skipping 28 matching lines @@
     This helps avoid noise with several rolls where one is sufficient,
     with no expectation changes.
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
     })
     b_package_spec = self.get_package_spec(repos['b'])
 
     # Set up a recipe in repo B depending on a module in repo A.
-    a_c1 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
+    self.update_recipe_module(repos['a'], 'a_module', {'foo': ['bar']})
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
-    b_c1 = self.update_recipe(
+    self.update_recipe(
         repos['b'], 'b_recipe', ['a/a_module'], [('a_module', 'foo')])
 
     # Change API of the recipe module in an incompatible way.
     a_c2 = self.update_recipe_module(repos['a'], 'a_module', {'baz': ['baz']})
 
     # Restore compatibility, but change expectations.
     a_c3 = self.update_recipe_module(repos['a'], 'a_module', {'foo': ['baz']})
 
     # Create another change that would result in a nontrivial roll,
     # which should not be picked - nontrivial rolls should be minimal.
@@ skipping 54 matching lines @@
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
         'c': ['b', 'a'],
     })
     b_package_spec = self.get_package_spec(repos['b'])
     c_package_spec = self.get_package_spec(repos['c'])
 
     # Set up a recipe in repo C depending on a module in repo B.
-    b_c1 = self.update_recipe_module(repos['b'], 'b_module', {'foo': ['bar']})
+    self.update_recipe_module(repos['b'], 'b_module', {'foo': ['bar']})
     roll_result = self.run_roll(repos['c'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
-    c_c1 = self.update_recipe(
+    self.update_recipe(
         repos['c'], 'c_recipe', ['b/b_module'], [('b_module', 'foo')])
 
     # Create a new commit in the A repo and roll it into B.
     a_c1 = self.commit_in_repo(repos['a'], message='c1')
     roll_result = self.run_roll(repos['b'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
     picked_roll = roll_result['picked_roll_details']
     self.assertEqual(
         str(b_package_spec.dump()).replace(
             repos['a']['revision'], a_c1['revision']),
         roll_result['picked_roll_details']['spec'])
 
     # Commit the roll.
     b_c2 = self.commit_in_repo(repos['b'], message='roll')
 
     # Change API of the recipe module in an incompatible way.
-    b_c3 = self.update_recipe_module(repos['b'], 'b_module', {'baz': ['baz']})
+    self.update_recipe_module(repos['b'], 'b_module', {'baz': ['baz']})
 
     roll_result = self.run_roll(repos['c'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
 
     expected_picked_roll = {
         'commit_infos': {
             'a': [
                 {
                     'author': a_c1['author_email'],
@@ skipping 25 matching lines @@
         0, picked_roll['recipes_simulation_test']['rc'])
 
   def test_no_backwards_roll(self):
     """Tests that we never roll backwards.
     """
     repos = self.repo_setup({
         'a': [],
         'b': ['a'],
         'c': ['b', 'a'],
     })
-    root_repo_spec = self.get_root_repo_spec(repos['c'])
+    self.get_root_repo_spec(repos['c'])
     b_repo_spec = self.get_git_repo_spec(repos['b'])
     c_package_spec = self.get_package_spec(repos['c'])
 
     # Create a new commit in A repo and roll it to B.
     a_c1 = self.commit_in_repo(repos['a'], message='c1')
     b_c1_rev = self.update_recipes_cfg(
         'b', self.updated_package_spec_pb(repos['b'], 'a', a_c1['revision']))
 
     # Roll above commits to C.
     roll_result = self.run_roll(repos['c'])
     self.assertTrue(roll_result['success'])
     self.assertTrue(roll_result['trivial'])
     picked_roll = roll_result['picked_roll_details']
     self.assertEqual(
         str(c_package_spec.dump()).replace(
             repos['a']['revision'], a_c1['revision']).replace(
                 repos['b']['revision'], b_c1_rev),
-        roll_result['picked_roll_details']['spec'])
+        picked_roll['spec'])
 
     # Create a new commit in B that would result in backwards roll.
     b_c2_rev = self.update_recipes_cfg(
         'b', self.updated_package_spec_pb(
             repos['b'], 'a', repos['a']['revision']))
 
     roll_result = self.run_roll(repos['c'])
     self.assertFalse(roll_result['success'])
     self.assertEqual([], roll_result['roll_details'])
 
@@ skipping 36 matching lines @@
         '--project=c',
         '--project=d',
     )
     self.assertFalse(roll_result['success'])
     self.assertFalse(bool(roll_result['roll_details']))
     self.assertFalse(bool(roll_result['rejected_candidates_details']))
 
 
 if __name__ == '__main__':
   sys.exit(unittest.main())