[Findit] Modify tryjob pipelines to trigger try jobs for test failure.

appengine/findit/waterfall/test/try_job_util_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 model import wf_analysis_status
 from model.wf_analysis import WfAnalysis
 from model.wf_try_job import WfTryJob
 from waterfall import try_job_util
 from waterfall import waterfall_config
+from waterfall.try_job_type import TryJobType
 
 
 class _MockRootPipeline(object):
   STARTED = False
 
   def __init__(self, *_):
     pass
 
   def start(self, *_, **__):
     _MockRootPipeline.STARTED = True
@@ skipping 98 matching lines @@
     }
 
     self.mock(
         try_job_util.try_job_pipeline, 'TryJobPipeline', _MockRootPipeline)
     _MockRootPipeline.STARTED = False
 
     try_job_util.ScheduleTryJobIfNeeded(failure_info)
 
     self.assertFalse(_MockRootPipeline.STARTED)
 
-  def testNotNeedANewTryJobIfNotCompileFailure(self):
-    master_name = 'm'
-    builder_name = 'b'
-    build_number = 223
-    failed_steps = {
-        'a': {
-            'current_failure': 223,
-            'first_failure': 223,
-            'last_pass': 222
-        }
-    }
-
-    need_try_job, failure_result_map, last_pass = try_job_util._NeedANewTryJob(
-        master_name, builder_name, build_number, failed_steps)
-
-    self.assertFalse(need_try_job)
-    self.assertEqual({}, failure_result_map)
-    self.assertIsNone(last_pass)
-
   def testNotNeedANewTryJobIfOneWithResultExists(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 223
     failed_steps = {
         'compile': {
             'current_failure': 223,
             'first_failure': 223,
             'last_pass': 220
         }
     }
 
     try_job = WfTryJob.Create(master_name, builder_name, build_number)
     try_job.compile_results = [['rev', 'failed']]
     try_job.status = wf_analysis_status.ANALYZED
     try_job.put()
 
-    need_try_job, failure_result_map, last_pass = try_job_util._NeedANewTryJob(
-        master_name, builder_name, build_number, failed_steps)
+    failure_result_map = {}
+    need_try_job, last_pass, try_job_type, targeted_tests = (
+        try_job_util._NeedANewTryJob(master_name, builder_name, build_number,
+                                     failed_steps, failure_result_map))
 
     expected_failure_result_map = {
         'compile': 'm/b/223'
     }
 
     self.assertFalse(need_try_job)
     self.assertEqual(expected_failure_result_map, failure_result_map)
     self.assertEqual(220, last_pass)
+    self.assertEqual(TryJobType.COMPILE, try_job_type)
+    self.assertIsNone(targeted_tests)
 
   def testNeedANewTryJobIfExistingOneHasError(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 223
     failed_steps = {
         'compile': {
             'current_failure': 223,
             'first_failure': 223,
             'last_pass': 220
         }
     }
 
     try_job = WfTryJob.Create(master_name, builder_name, build_number)
     try_job.status = wf_analysis_status.ERROR
     try_job.put()
 
-    need_try_job, failure_result_map, last_pass = try_job_util._NeedANewTryJob(
-        master_name, builder_name, build_number, failed_steps)
+    failure_result_map = {}
+    need_try_job, last_pass, try_job_type, targeted_tests = (
+        try_job_util._NeedANewTryJob(master_name, builder_name, build_number,
+                                     failed_steps, failure_result_map))
 
     expected_failure_result_map = {
         'compile': 'm/b/223'
     }
     self.assertTrue(need_try_job)
     self.assertEqual(expected_failure_result_map, failure_result_map)
     self.assertEqual(220, last_pass)
+    self.assertEqual(TryJobType.COMPILE, try_job_type)
+    self.assertIsNone(targeted_tests)
 
   def testNotNeedANewTryJobIfLastPassCannotDetermine(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 223
     failed_steps = {
         'compile': {
             'current_failure': 223,
             'first_failure': 223
         }
     }
 
     try_job = WfTryJob.Create(master_name, builder_name, build_number)
     try_job.status = wf_analysis_status.ERROR
     try_job.put()
 
-    need_try_job, failure_result_map, last_pass = try_job_util._NeedANewTryJob(
-        master_name, builder_name, build_number, failed_steps)
+    failure_result_map = {}
+    need_try_job, last_pass, try_job_type, targeted_tests = (
+        try_job_util._NeedANewTryJob(master_name, builder_name, build_number,
+                                     failed_steps, failure_result_map))
 
     self.assertFalse(need_try_job)
     self.assertEqual({}, failure_result_map)
     self.assertIsNone(last_pass)
+    self.assertEqual(TryJobType.COMPILE, try_job_type)
+    self.assertIsNone(targeted_tests)
+
+  def testNeedANewTryJobIfTestFailureNonSwarming(self):
+    master_name = 'm'
+    builder_name = 'b'
+    build_number = 223
+    failed_steps = {
+        'a': {
+            'current_failure': 223,
+            'first_failure': 223,
+            'last_pass': 222
+        },
+        'b': {
+            'current_failure': 223,
+            'first_failure': 222,
+            'last_pass': 221
+        }
+    }
+
+    failure_result_map = {}
+    need_try_job, last_pass, try_job_type, targeted_tests = (
+        try_job_util._NeedANewTryJob(master_name, builder_name, build_number,
+                                     failed_steps, failure_result_map))
+
+    expected_failure_result_map = {
+        'a': 'm/b/223',
+        'b': 'm/b/222'
+    }
+
+    expected_targeted_tests = {
+        'a': []
+    }
+
+    self.assertTrue(need_try_job)
+    self.assertEqual(expected_failure_result_map, failure_result_map)
+    self.assertEqual(222, last_pass)
+    self.assertEqual('test', try_job_type)
+    self.assertEqual(expected_targeted_tests, targeted_tests)
+
+  def testNeedANewTryJobIfTestFailureSwarming(self):
+    master_name = 'm'
+    builder_name = 'b'
+    build_number = 223
+    failed_steps = {
+        'a': {
+            'current_failure': 223,
+            'first_failure': 222,
+            'last_pass': 221,
+            'tests': {
+                'a.t1': {
+                    'current_failure': 223,
+                    'first_failure': 223,
+                    'last_pass': 221
+                },
+                'a.t2': {
+                    'current_failure': 223,
+                    'first_failure': 222,
+                    'last_pass': 221
+                },
+                'a.t3': {
+                    'current_failure': 223,
+                    'first_failure': 223,
+                    'last_pass': 222
+                }
+            }
+        },
+        'b': {
+            'current_failure': 223,
+            'first_failure': 222,
+            'last_pass': 221,
+            'tests': {
+                'b.t1': {
+                    'current_failure': 223,
+                    'first_failure': 222,
+                    'last_pass': 221
+                },
+                'b.t2': {
+                    'current_failure': 223,
+                    'first_failure': 222,
+                    'last_pass': 221
+                }
+            }
+        }
+    }
+
+    failure_result_map = {}
+    need_try_job, last_pass, try_job_type, targeted_tests = (
+        try_job_util._NeedANewTryJob(master_name, builder_name, build_number,
+                                     failed_steps, failure_result_map))
+
+    expected_failure_result_map = {
+        'a': {
+            'a.t1': 'm/b/223',
+            'a.t2': 'm/b/222',
+            'a.t3': 'm/b/223'
+        },
+        'b': {
+            'b.t1': 'm/b/222',
+            'b.t2': 'm/b/222'
+        },
+    }
+
+    expected_targeted_tests = {
+        'a': ['a.t1', 'a.t3']
+    }
+
+    self.assertTrue(need_try_job)
+    self.assertEqual(expected_failure_result_map, failure_result_map)
+    self.assertEqual(221, last_pass)
+    self.assertEqual('test', try_job_type)
+    self.assertEqual(expected_targeted_tests, targeted_tests)
 
   def testNeedANewTryJob(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 223
     failure_info = {
         'master_name': master_name,
         'builder_name': builder_name,
         'build_number': build_number,
         'failed_steps': {
@@ skipping 33 matching lines @@
         'compile': {
             'failed_targets': [
                 {'target': 'a.exe'},
                 {'source': 'b.cc',
                  'target': 'b.o'}]
         }
     }
 
     self.assertEqual(
         try_job_util._GetFailedTargetsFromSignals(signals), ['a.exe'])
-