[Findit] Report the error from the last flake swarming task that failed in master_flake_analysis.py

appengine/findit/waterfall/flake/test/recursive_flake_pipeline_test.py

 # Copyright 2016 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.
 
 from datetime import datetime
 import mock
 
 from common import constants
 from common.pipeline_wrapper import pipeline_handlers
 from model import analysis_status
@@ skipping 15 matching lines @@
   def _CreateAndSaveMasterFlakeAnalysis(
       self, master_name, builder_name, build_number, step_name,
       test_name, status):
     analysis = MasterFlakeAnalysis.Create(
         master_name, builder_name, build_number, step_name, test_name)
     analysis.status = status
     analysis.Save()
 
   def _CreateAndSaveFlakeSwarmingTask(
       self, master_name, builder_name, build_number, step_name, test_name,
-      status=analysis_status.PENDING, number_of_iterations=0):
+      status=analysis_status.PENDING, number_of_iterations=0, error=None):
     flake_swarming_task = FlakeSwarmingTask.Create(
         master_name, builder_name, build_number, step_name, test_name)
     flake_swarming_task.status = status
     flake_swarming_task.tries = number_of_iterations
+    flake_swarming_task.error = error
     flake_swarming_task.put()
 
   def _GenerateDataPoints(self, pass_rates, build_numbers):
     data_points = []
     for i in range(0, len(pass_rates)):
       data_point = DataPoint()
       data_point.pass_rate = pass_rates[i]
       data_point.build_number = build_numbers[i]
       data_points.append(data_point)
     return data_points
@@ skipping 360 matching lines @@
   @mock.patch.object(
       recursive_flake_pipeline, '_UpdateBugWithResult', return_value=None)
   def testNextBuildPipelineForFailedSwarmingTask(self, *_):
     master_name = 'm'
     builder_name = 'b'
     master_build_number = 100
     build_number = 100
     step_name = 's'
     test_name = 't'
     test_result_future = 'trf'
+    swarming_task_error = {
+        'code': 1,
+        'message': 'some failure message',
+    }
     flakiness_algorithm_results_dict = {
         'flakes_in_a_row': 0,
         'stable_in_a_row': 0,
         'stabled_out': False,
         'flaked_out': False,
         'last_build_number': 0,
         'lower_boundary': None,
         'upper_boundary': None,
         'lower_boundary_result': None,
         'sequential_run_index': 0
 
     }
     self._CreateAndSaveMasterFlakeAnalysis(
         master_name, builder_name, build_number, step_name,
         test_name, status=analysis_status.PENDING
     )
     self._CreateAndSaveFlakeSwarmingTask(
         master_name, builder_name, build_number, step_name,
-        test_name, status=analysis_status.ERROR
+        test_name, status=analysis_status.ERROR, error=swarming_task_error
     )
     analysis = MasterFlakeAnalysis.GetVersion(
         master_name, builder_name, build_number, step_name, test_name)
     data_point = DataPoint()
     data_point.pass_rate = .5
     data_point.build_number = 100
     analysis.data_points.append(data_point)
     analysis.put()
 
     queue_name = {'x': False}
     def my_mocked_run(*_, **__):
       queue_name['x'] = True  # pragma: no cover
 
     self.mock(
         recursive_flake_pipeline.RecursiveFlakePipeline, 'start', my_mocked_run)
     NextBuildNumberPipeline.run(
         NextBuildNumberPipeline(), master_name, builder_name,
         master_build_number, build_number, step_name, test_name, 1,
         test_result_future, flakiness_algorithm_results_dict)
     self.assertFalse(queue_name['x'])
+    self.assertEqual(swarming_task_error, analysis.error)
 
   @mock.patch.object(
       recursive_flake_pipeline, '_GetETAToStartAnalysis', return_value=None)
   @mock.patch.object(
       recursive_flake_pipeline, '_UpdateBugWithResult', return_value=None)
   def testNextBuildPipelineForNewRecursionStabledFlakedOut(self, *_):
     master_name = 'm'
     builder_name = 'b'
     master_build_number = 100
     build_number = 100
@@ skipping 389 matching lines @@
         master_name, builder_name, master_build_number, step_name, test_name)
     self.assertEqual(analysis_status.COMPLETED, analysis.status)
 
   def testUpdateAnalysisUponCompletionFound(self):
     analysis = MasterFlakeAnalysis.Create('m', 'b', 123, 's', 't')
     analysis.suspected_flake_build_number = 100
     recursive_flake_pipeline._UpdateAnalysisStatusUponCompletion(
         analysis, analysis_status.COMPLETED, None)
     self.assertEqual(analysis.result_status, result_status.FOUND_UNTRIAGED)
 
+  def testUpdateAnalysisUponCompletionError(self):
+    expected_error = {
+        'code': 1,
+        'message': 'some error message'
+    }
+    analysis = MasterFlakeAnalysis.Create('m', 'b', 123, 's', 't')
+    analysis.suspected_flake_build_number = 100
+    recursive_flake_pipeline._UpdateAnalysisStatusUponCompletion(
+        analysis, analysis_status.COMPLETED, expected_error)
+    self.assertEqual(expected_error, analysis.error)
+
   def testGetListOfNearbyBuildNumbers(self):
     self.assertEqual(
         [1],
         recursive_flake_pipeline._GetListOfNearbyBuildNumbers(1, 0))
     self.assertEqual(
         [1],
         recursive_flake_pipeline._GetListOfNearbyBuildNumbers(1, -1))
     self.assertEqual(
         [1, 2],
         recursive_flake_pipeline._GetListOfNearbyBuildNumbers(1, 1))
@@ skipping 230 matching lines @@
     calls = mocked_pipeline.mock_calls
     self.assertEqual(2, len(calls))
 
     _, args, __ = calls[0]
     bug_id, comment, labels = args
     self.assertEqual(123, bug_id)
     self.assertEqual(['AnalyzedByFindit'], labels)
     self.assertTrue('om / ob / os' in comment)
 
     self.assertEqual(mock.call().start(queue_name='queue'), calls[1])