Only report Patch failure on infra error and refactor code

appengine/chromium_try_flakes/handlers/test/flake_issues_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.
 
 import datetime
 import json
 import mock
 import urllib2
 
 from google.appengine.datastore import datastore_stub_util
@@ skipping 62 matching lines @@
 
     # Ignore steps that are duplicating error in another step.
     {'results': [2], 'name': 'steps', 'text': ['bar10']},
     {'results': [2], 'name': '[swarming] foo7', 'text': ['bar11']},
     {'results': [2], 'name': 'presubmit', 'text': ['bar12']},
     {'results': [2], 'name': 'recipe failure reason', 'text': ['bar12a']},
     {'results': [2], 'name': 'test results', 'text': ['bar12b']},
     {'results': [2], 'name': 'Uncaught Exception', 'text': ['bar12c']},
     {'results': [2], 'name': 'bot_update', 'text': ['bot_update PATCH FAILED']},
 
+    # Detect infra-failure for 'Patch failure', but igore normal error.
+    {'results': [4], 'name': 'Patch failure', 'text': ['Patch failure']},
+    {'results': [2], 'name': 'Patch failure', 'text': ['Patch failure']},
+
     # Only count first step (with patch) and ignore summary step.
     {'results': [2], 'name': 'foo8 xx (with patch)', 'text': ['bar13']},
     {'results': [0], 'name': 'foo8 xx (without patch)', 'text': ['bar14']},
     {'results': [2], 'name': 'foo8 xx (retry summary)', 'text': ['bar15']},
   ]
 })
 
 
 class MockComment(object):
   def __init__(self, created, author, comment=None):
@@ skipping 579 matching lines @@
 
   def test_get_flaky_run_reason(self):
     now = datetime.datetime.utcnow()
     br_f, br_s = self._create_build_runs(now - datetime.timedelta(hours=1), now)
 
     urlfetch_mock = mock.Mock(side_effect = [
         # JSON results for the build.
         mock.Mock(status_code=200, content=TEST_BUILDBOT_JSON_REPLY),
         # JSON results for step "foo1".
         mock.Mock(status_code=200, content=TEST_TEST_RESULTS_REPLY),
+        # JSON results for step "Patch failure".
+        mock.Mock(status_code=404),
         # For step "foo8 xx (with patch)", something failed while parsing JSON,
         # step text ("bar13") should be reported as flake.
         Exception(),
     ])
 
     # We also create one Flake to test that it is correctly updated. Other Flake
     # entities will be created automatically.
     Flake(id='foo2', name='foo2', occurrences=[],
           last_time_seen=datetime.datetime.min).put()
 
@@ skipping 16 matching lines @@
       mock.call(
         'http://build.chromium.org/p/test.master/json/builders/test-builder/'
         'builds/100'),
       # Verify that we've used correct URLs to retrieve test-results GTest JSON.
       mock.call(
         'http://test-results.appspot.com/testfile?builder=test-builder&'
         'name=full_results.json&master=test.master&testtype=foo1&'
         'buildnumber=100'),
       mock.call(
         'http://test-results.appspot.com/testfile?builder=test-builder&'
+        'name=full_results.json&master=test.master&testtype=Patch&'
+        'buildnumber=100'),
+      mock.call(
+        'http://test-results.appspot.com/testfile?builder=test-builder&'
         'name=full_results.json&master=test.master&'
         'testtype=foo8%20%28with%20patch%29&buildnumber=100')])
 
     # Expected flakes to be found: list of (step_name, test_name).
-    expected_flakes = [
+    # We compare sets below, because order of entities returned by datastore
+    # doesn't have to be same as steps above.
+    expected_flakes = set([
         ('foo1', 'test2.a'),
         ('foo1', 'test2.d'),
         ('foo2', 'foo2'),
         ('foo8 xx (with patch)', 'foo8 (with patch)'),
-    ]
+        ('Patch failure', 'Patch'),
+    ])
 
     flake_occurrences = flaky_run.flakes
     self.assertEqual(len(flake_occurrences), len(expected_flakes))
-    actual_flake_occurrences = [
-        (fo.name, fo.failure) for fo in flake_occurrences]
+    actual_flake_occurrences = set([
+        (fo.name, fo.failure) for fo in flake_occurrences])
     self.assertEqual(expected_flakes, actual_flake_occurrences)
 
-    # We compare sets below, because order of flakes returned by datastore
-    # doesn't have to be same as steps above.
     flakes = Flake.query().fetch()
     self.assertEqual(len(flakes), len(expected_flakes))
     expected_flake_names = set([ef[1] for ef in expected_flakes])
     actual_flake_names = set([f.name for f in flakes])
     self.assertEqual(expected_flake_names, actual_flake_names)
 
     for flake in flakes:
       self.assertEqual(flake.occurrences, [flaky_run.key])
 
   def test_flattens_tests_correctly(self):
     passed, failed, skipped = CreateFlakyRun._flatten_tests(
         json.loads(TEST_TEST_RESULTS_REPLY)['tests'], '/')
     self.assertEqual(set(passed), set(['test1']))
     self.assertEqual(set(failed), set(['test2/a', 'test2/d']))
     self.assertEqual(set(skipped), set(['test2/b']))