[Findit] Compare lists to lists instead of lists to tuples, and change tests

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 datetime import datetime
 from datetime import timedelta
 
 from common.waterfall import failure_type
 from model import analysis_status
 from model.wf_analysis import WfAnalysis
@@ skipping 383 matching lines @@
     # Run pipeline with signals that have the same failed output nodes.
     # Observe no new group creation.
     self.assertFalse(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.COMPILE,
         blame_list, None, signals, None))
 
     analysis_2 = WfAnalysis.Get(master_name_2, builder_name, build_number)
     self.assertEqual(
         [master_name, builder_name, build_number], analysis_2.failure_group_key)
 
-  def testGroupCompilesWithRelatedFailures(self):
+  def testGroupCompilesWithRelatedFailuresWithHeuristicResult(self):
     master_name = 'm1'
     builder_name = 'b'
     build_number = 1
+    master_name_2 = 'm2'
+
+    blame_list = ['a']
+
+    signals = {
+        'compile': {
+            'failed_output_nodes': [
+                'abc.obj'
+            ]
+        }
+    }
+
+    heuristic_result = {
+        'failures': [
+            {
+                'step_name': 'step1',
+                'suspected_cls': [
+                    {
+                        'revision': 'rev1',
+                    }
+                ],
+            }
+        ]
+    }
+
+    WfAnalysis.Create(master_name, builder_name, build_number).put()
+    # Run pipeline with signals that have certain failed output nodes.
+    # Observe new group creation.
+    self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
+        master_name, builder_name, build_number, failure_type.COMPILE,
+        blame_list, None, signals, heuristic_result))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
+
+    WfAnalysis.Create(master_name_2, builder_name, build_number).put()
+    # Run pipeline with signals that have the same failed output nodes.
+    # Observe no new group creation.
+    self.assertFalse(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
+        master_name_2, builder_name, build_number, failure_type.COMPILE,
+        blame_list, None, signals, heuristic_result))
+    self.assertIsNone(
+        WfFailureGroup.Get(master_name_2, builder_name, build_number))
+
+  def testGroupCompilesWithRelatedFailuresWithoutHeuristicResult(self):
+    master_name = 'm1'
+    builder_name = 'b'
+    build_number = 1
     master_name_2 = 'm2'
 
     blame_list = ['a']
 
     signals = {
         'compile': {
             'failed_output_nodes': [
                 'abc.obj'
             ]
         }
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed output nodes.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.COMPILE,
         blame_list, None, signals, None))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have the same failed output nodes.
     # Observe no new group creation.
     self.assertFalse(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.COMPILE,
         blame_list, None, signals, None))
     self.assertIsNone(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
@@ skipping 14 matching lines @@
             ]
         }
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed output nodes.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.COMPILE,
         blame_list_1, None, signals, None))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have different failed output nodes.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.COMPILE,
         blame_list_2, None, signals, None))
     self.assertTrue(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
@@ skipping 25 matching lines @@
             }
         ]
     }
 
     heuristic_result_2 = {
         'failures': [
             {
                 'step_name': 'step1',
                 'suspected_cls': [
                     {
-                        'revision': 'rev1',
+                        'revision': 'rev2',
                     }
                 ],
             }
         ]
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed output nodes.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.COMPILE,
         blame_list, None, signals,
         heuristic_result_1))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have different failed output nodes.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.COMPILE,
         blame_list, None, signals, heuristic_result_2))
     self.assertTrue(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
@@ skipping 20 matching lines @@
             ]
         }
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed output nodes.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.COMPILE,
         blame_list, None, signals_1, None))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have different failed output nodes.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.COMPILE,
         blame_list, None, signals_2, None))
     self.assertTrue(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
   def testDoNotGroupTestWithNoSteps(self):
     master_name = 'm1'
     builder_name = 'b'
     build_number = 1
 
     blame_list = ['a']
 
     failed_steps = {}
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have zero failed steps.
     # Observe that the build failure is unique, but there is no new group
     # creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.TEST, blame_list,
         failed_steps, None, None))
     self.assertIsNone(
         WfFailureGroup.Get(master_name, builder_name, build_number))
 
-  def testGroupTestsWithRelatedSteps(self):
+  def testGroupTestsWithRelatedStepsWithHeuristicResult(self):
     master_name = 'm1'
     builder_name = 'b'
     build_number = 1
+    master_name_2 = 'm2'
+
+    blame_list = ['a']
+
+    failed_steps = {
+        'step_a': {
+            'current_failure': 3,
+            'first_failure': 2,
+            'last_pass': 1
+        }
+    }
+
+    heuristic_result = {
+        'failures': [
+            {
+                'step_name': 'step1',
+                'suspected_cls': [
+                    {
+                        'revision': 'rev1',
+                    }
+                ],
+            }
+        ]
+    }
+
+    WfAnalysis.Create(master_name, builder_name, build_number).put()
+    # Run pipeline with signals that have certain failed steps.
+    # Observe new group creation.
+    self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
+        master_name, builder_name, build_number, failure_type.TEST, blame_list,
+        failed_steps, None, heuristic_result))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
+
+    WfAnalysis.Create(master_name_2, builder_name, build_number).put()
+    # Run pipeline with signals that have the same failed steps.
+    # Observe no new group creation.
+    self.assertFalse(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
+        master_name_2, builder_name, build_number, failure_type.TEST,
+        blame_list, failed_steps, None, heuristic_result))
+    self.assertIsNone(
+        WfFailureGroup.Get(master_name_2, builder_name, build_number))
+
+  def testGroupTestsWithRelatedStepsWithoutHeuristicResult(self):
+    master_name = 'm1'
+    builder_name = 'b'
+    build_number = 1
     master_name_2 = 'm2'
 
     blame_list = ['a']
 
     failed_steps = {
         'step_a': {
             'current_failure': 3,
             'first_failure': 2,
             'last_pass': 1
         }
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed steps.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.TEST, blame_list,
         failed_steps, None, None))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have the same failed steps.
     # Observe no new group creation.
     self.assertFalse(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.TEST,
         blame_list, failed_steps, None, None))
     self.assertIsNone(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
@@ skipping 13 matching lines @@
         }
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed steps.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.TEST,
         blame_list_1, failed_steps, None,
         None))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have different failed steps.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.TEST,
         blame_list_2, failed_steps, None, None))
     self.assertTrue(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
@@ skipping 24 matching lines @@
             }
         ]
     }
 
     heuristic_result_2 = {
         'failures': [
             {
                 'step_name': 'step1',
                 'suspected_cls': [
                     {
-                        'revision': 'rev1',
+                        'revision': 'rev2',
                     }
                 ],
             }
         ]
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed steps.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.TEST, blame_list,
         failed_steps, None, heuristic_result_1))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have different failed steps.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.TEST,
         blame_list, failed_steps, None, heuristic_result_2))
     self.assertTrue(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
@@ skipping 20 matching lines @@
             'last_pass': 1
         }
     }
 
     WfAnalysis.Create(master_name, builder_name, build_number).put()
     # Run pipeline with signals that have certain failed steps.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name, builder_name, build_number, failure_type.TEST, blame_list,
         failed_steps_1, None, None))
-    self.assertTrue(WfFailureGroup.Get(master_name, builder_name, build_number))
+    self.assertIsNotNone(
+        WfFailureGroup.Get(master_name, builder_name, build_number))
 
     WfAnalysis.Create(master_name_2, builder_name, build_number).put()
     # Run pipeline with signals that have different failed steps.
     # Observe new group creation.
     self.assertTrue(try_job_util._IsBuildFailureUniqueAcrossPlatforms(
         master_name_2, builder_name, build_number, failure_type.TEST,
         blame_list, failed_steps_2, None, None))
     self.assertTrue(
         WfFailureGroup.Get(master_name_2, builder_name, build_number))
 
@@ skipping 320 matching lines @@
                 {'source': 'b.cc', 'target': 'b.o'},
             ]
         }
     }
 
     self.assertEqual(
         try_job_util._GetFailedTargetsFromSignals(
             signals, 'master1', 'builder1'),
         ['b.o'])
 
-  def testGenPotentialCulpritTupleListNoHeuristicResult(self):
+  def testGetSuspectedCLsWithFailuresNoHeuristicResult(self):
     heuristic_result = None
     expected_suspected_revisions = []
     self.assertEqual(
         expected_suspected_revisions,
-        sorted(try_job_util.GenPotentialCulpritTupleList(heuristic_result)))
+        sorted(try_job_util.GetSuspectedCLsWithFailures(heuristic_result)))
 
-  def testGenPotentialCulpritTupleListEmptyHeuristicResult(self):
+  def testGetSuspectedCLsWithFailuresEmptyHeuristicResult(self):
     heuristic_result = {}
     expected_suspected_revisions = []
     self.assertEqual(
         expected_suspected_revisions,
-        sorted(try_job_util.GenPotentialCulpritTupleList(heuristic_result)))
+        sorted(try_job_util.GetSuspectedCLsWithFailures(heuristic_result)))
 
-  def testGenPotentialCulpritTupleList(self):
+  def testGetSuspectedCLsWithFailures(self):
     heuristic_result = {
         'failures': [
             {
                 'step_name': 'step1',
                 'suspected_cls': [],
             },
             {
                 'step_name': 'step2',
                 'suspected_cls': [
                     {
@@ skipping 29 matching lines @@
                             {
                                 'revision': 'ghi'
                             }
                         ]
                     }
                 ]
             }
         ]
     }
     expected_suspected_revisions = [
-        ('step2', 'r1', None),
-        ('step2', 'r2', None),
-        ('step3', 'abc', 'super_test_1'),
-        ('step3', 'def', 'super_test_2'),
-        ('step3', 'ghi', 'super_test_2')
+        ['step2', 'r1', None],
+        ['step2', 'r2', None],
+        ['step3', 'abc', 'super_test_1'],
+        ['step3', 'def', 'super_test_2'],
+        ['step3', 'ghi', 'super_test_2']
     ]
     self.assertEqual(
         expected_suspected_revisions,
-        sorted(try_job_util.GenPotentialCulpritTupleList(heuristic_result)))
+        sorted(try_job_util.GetSuspectedCLsWithFailures(heuristic_result)))
 
   def testGetSuspectsFromHeuristicResultForCompile(self):
     heuristic_result = {
         'failures': [
             {
                 'step_name': 'compile',
                 'suspected_cls': [
                     {
                         'revision': 'r1',
                     },
@@ skipping 42 matching lines @@
         try_job_util._GetSuspectsFromHeuristicResult(heuristic_result))
 
   def testShouldBailOutforOutdatedBuild(self):
     yesterday = datetime.utcnow() - timedelta(days=1)
     build = WfBuild.Create('m', 'b', 1)
     build.start_time = yesterday
     self.assertTrue(try_job_util._ShouldBailOutForOutdatedBuild(build))
 
     build.start_time = yesterday + timedelta(hours=1)
     self.assertFalse(try_job_util._ShouldBailOutForOutdatedBuild(build))