[Findit] Pipeline change to save suspected cls to data store.

appengine/findit/waterfall/test/identify_culprit_pipeline_test.py

 # Copyright 2015 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 testing_utils import testing
 
 from common.pipeline_wrapper import pipeline_handlers
+from common.waterfall import failure_type
+from model import analysis_approach_type
 from model import analysis_status
 from model import result_status
 from model.wf_analysis import WfAnalysis
+from model.wf_suspected_cl import WfSuspectedCL
 from waterfall import build_failure_analysis
 from waterfall import identify_culprit_pipeline
 
 
 class IdentifyCulpritPipelineTest(testing.AppengineTestCase):
   app_module = pipeline_handlers._APP
 
   def testGetSuspectedCLs(self):
     dummy_result = {
         'failures': [
@@ skipping 173 matching lines @@
     }
 
     self.assertEqual(result_status.NOT_FOUND_UNTRIAGED,
                      identify_culprit_pipeline._GetResultAnalysisStatus(
                          dummy_result))
 
   def testIdentifyCulpritPipeline(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 123
+    repo_name = 'chromium'
+    revision = 'r99_1'
 
     analysis = WfAnalysis.Create(master_name, builder_name, build_number)
     analysis.result = None
     analysis.status = analysis_status.RUNNING
     analysis.put()
 
     failure_info = {
       'master_name': master_name,
       'builder_name': builder_name,
       'build_number': build_number,
+      'failure_type': failure_type.TEST
     }
     change_logs = {}
     deps_info = {}
     signals = {}
 
-    dummy_result = {'failures': []}
+    dummy_result = {
+        'failures': [
+            {
+                'step_name': 'a',
+                'first_failure': 98,
+                'last_pass': None,
+                'suspected_cls': [
+                    {
+                        'build_number': 99,
+                        'repo_name': repo_name,
+                        'revision': revision,
+                        'commit_position': None,
+                        'url': None,
+                        'score': 1,
+                        'hints': {
+                            'modified f99_2.cc (and it was in log)': 1,
+                        },
+                    }
+                ],
+            }
+        ]
+    }
 
     def MockAnalyzeBuildFailure(*_):
       return dummy_result
 
     self.mock(build_failure_analysis,
               'AnalyzeBuildFailure', MockAnalyzeBuildFailure)
 
     pipeline = identify_culprit_pipeline.IdentifyCulpritPipeline(
         failure_info, change_logs, deps_info, signals, True)
     pipeline.start()
     self.execute_queued_tasks()
 
-    expected_suspected_cls = []
+    expected_suspected_cls = [
+        {
+            'repo_name': repo_name,
+            'revision': revision,
+            'commit_position': None,
+            'url': None
+        }
+    ]
 
     analysis = WfAnalysis.Get(master_name, builder_name, build_number)
     self.assertTrue(analysis.build_completed)
     self.assertIsNotNone(analysis)
     self.assertEqual(dummy_result, analysis.result)
     self.assertEqual(analysis_status.COMPLETED, analysis.status)
-    self.assertIsNone(analysis.result_status)
+    self.assertIsNotNone(analysis.result_status)
     self.assertEqual(expected_suspected_cls, analysis.suspected_cls)
+
+    suspected_cl = WfSuspectedCL.Get(repo_name, revision)
+    self.assertIsNotNone(suspected_cl)
+    self.assertEqual(
+        [[master_name, builder_name, build_number]], suspected_cl.builds)
+
+  def testCreateWfSuspectedCL(self):
+    build_info = ['m', 'b', 123]
+    compile_failure_type = failure_type.COMPILE
+    repo_name = 'chromium'
+    revision = 'r1'
+    commit_position = 1
+
+    self.assertIsNone(WfSuspectedCL.Get(repo_name, revision))
+
+    identify_culprit_pipeline._SaveSuspectedCL(
+        build_info, compile_failure_type, repo_name, revision, commit_position)
+
+    suspected_cl = WfSuspectedCL.Get(repo_name, revision)
+
+    self.assertIsNotNone(suspected_cl)
+    self.assertEqual(analysis_approach_type.HEURISTIC, suspected_cl.approach)
+    self.assertEqual(compile_failure_type, suspected_cl.failure_type)
+    self.assertEqual([build_info], suspected_cl.builds)
+
+  def testUpdateWfSuspectedCL(self):
+    build_info = ['m', 'b', 122]
+    test_failure_type = failure_type.TEST
+    repo_name = 'chromium'
+    revision = 'r2'
+    commit_position = 2
+
+    suspected_cl = WfSuspectedCL.Create(repo_name, revision, commit_position)
+    suspected_cl.approach = analysis_approach_type.TRY_JOB
+    suspected_cl.builds.append(['m', 'b1', 100])
+    suspected_cl.failure_type = test_failure_type
+    suspected_cl.put()
+
+    identify_culprit_pipeline._SaveSuspectedCL(
+        build_info, test_failure_type, repo_name, revision, commit_position)
+
+    suspected_cl = WfSuspectedCL.Get(repo_name, revision)
+
+    self.assertIsNotNone(suspected_cl)
+    self.assertEqual(analysis_approach_type.BOTH, suspected_cl.approach)
+    self.assertEqual(test_failure_type, suspected_cl.failure_type)
+    self.assertEqual([['m', 'b1', 100], build_info], suspected_cl.builds)
+
+  def testUpdateWfSuspectedCLAddanotherHeuristic(self):
+    build_info = ['m', 'b', 122]
+    test_failure_type = failure_type.TEST
+    repo_name = 'chromium'
+    revision = 'r2'
+    commit_position = 2
+
+    suspected_cl = WfSuspectedCL.Create(repo_name, revision, commit_position)
+    suspected_cl.approach = analysis_approach_type.HEURISTIC
+    suspected_cl.put()
+
+    identify_culprit_pipeline._SaveSuspectedCL(
+        build_info, test_failure_type, repo_name, revision, commit_position)
+
+    suspected_cl = WfSuspectedCL.Get(repo_name, revision)
+
+    self.assertEqual(analysis_approach_type.HEURISTIC, suspected_cl.approach)
+
+  def testUpdateWfSuspectedCLRerun(self):
+    build_info = ['m', 'b', 122]
+    test_failure_type = failure_type.TEST
+    repo_name = 'chromium'
+    revision = 'r2'
+    commit_position = 2
+
+    suspected_cl = WfSuspectedCL.Create(repo_name, revision, commit_position)
+    suspected_cl.builds = [build_info]
+    suspected_cl.put()
+
+    identify_culprit_pipeline._SaveSuspectedCL(
+        build_info, test_failure_type, repo_name, revision, commit_position)
+
+    suspected_cl = WfSuspectedCL.Get(repo_name, revision)
+
+    self.assertEqual([build_info], suspected_cl.builds)
+
+  def testGetResultAnalysisStatusNone(self):
+    self.assertIsNone(identify_culprit_pipeline._GetResultAnalysisStatus([]))
+
+  def testGetSuspectedCLsEmpty(self):
+    self.assertEqual([], identify_culprit_pipeline._GetSuspectedCLs([]))