Move flaky run processing into a taskqueue

appengine/chromium_try_flakes/status/test/cq_status_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
 from google.appengine.ext import ndb
 from google.appengine.runtime import DeadlineExceededError
 
 import main
 from model.fetch_status import FetchStatus
-from model.flake import Flake, FlakyRun
+from model.flake import Flake
 from model.build_run import BuildRun, PatchsetBuilderRuns
 from status import cq_status
 from testing_utils import testing
 
 
-TEST_BUILDBOT_JSON_REPLY = json.dumps({
-  'steps': [
-    # Simple case.
-    {'results': [2], 'name': 'foo1', 'text': ['bar1']},
-
-    # Invalid test results.
-    {'results': [2], 'name': 'foo2', 'text': ['TEST RESULTS WERE INVALID']},
-
-    # GTest tests.
-    {
-      'results': [2],
-      'name': 'foo3',
-      'text': ['failures:<br/>bar2<br/>bar3<br/><br/>ignored:<br/>bar4']
-    },
-
-    # GPU tests.
-    {
-      'results': [2],
-      'name': 'foo4',
-      'text': ['<"http://url/path?query&tests=bar5,bar6,,bar7">']
-    },
-
-    # Ignore non-success non-failure results (7 is TRY_PENDING).
-    {'results': [7], 'name': 'foo5', 'text': ['bar8']},
-
-    # Ignore steps that are failing without patch too (ToT is broken).
-    {'results': [2], 'name': 'foo6 (with patch)', 'text': ['bar9']},
-    {'results': [2], 'name': 'foo6 (without patch)', 'text': ['bar9']},
-
-    # 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']},
-
-    # Only count first step (with patch) and ignore summary step.
-    {'results': [2], 'name': 'foo8 (with patch)', 'text': ['bar13']},
-    {'results': [0], 'name': 'foo8 (without patch)', 'text': ['bar14']},
-    {'results': [2], 'name': 'foo8', 'text': ['bar15']},
-
-    # GTest without flakes.
-    {
-      'results': [2],
-      'name': 'foo9',
-      'text': ['failures:<br/><br/><br/>']
-    },
-
-  ]
-})
-
 # Test results below capture various variants in which results may be processed.
 # Special attention should be paid to the 'issue' and 'patchset' fields as code
 # is expected to correctly process results from different issues and patchsets
 # independently of each other.
 TEST_CQ_STATUS_RESPONSE = json.dumps({
   'more': False,
   'cursor': '',
   'results': [
     # Ignored because action field is missing.
     {
@@ skipping 312 matching lines @@
     path = '/cron/update_stale_issues'
     response = self.test_app.get(path, headers={'X-AppEngine-Cron': 'true'})
     self.assertEqual(200, response.status_int)
 
     tasks = self.taskqueue_stub.get_filtered_tasks(queue_names='issue-updates')
     self.assertEqual(len(tasks), 3)
     self.assertEqual(tasks[0].url, '/issues/update-if-stale/123')
     self.assertEqual(tasks[1].url, '/issues/update-if-stale/234')
     self.assertEqual(tasks[2].url, '/issues/update-if-stale/345')
 
-  def _create_flaky_run(self, ts, tf):
-    pbr = PatchsetBuilderRuns(
-        issue=123456789, patchset=20001, master='test.master',
-        builder='test-builder').put()
-    br_f = BuildRun(parent=pbr, buildnumber=100, result=2, time_started=ts,
-                    time_finished=tf).put()
-    br_s = BuildRun(parent=pbr, buildnumber=101, result=0, time_started=ts,
-                    time_finished=tf).put()
-    return FlakyRun(failure_run=br_f, success_run=br_s,
-                    failure_run_time_started=ts,
-                    failure_run_time_finished=tf).put()
-
-  def test_get_flaky_run_reason_ignores_invalid_json(self):
-    now = datetime.datetime.utcnow()
-    fr_key = self._create_flaky_run(now - datetime.timedelta(hours=1), now)
-
-    urlfetch_mock = mock.Mock()
-    urlfetch_mock.return_value.content = 'invalid-json'
-
-    with mock.patch('google.appengine.api.urlfetch.fetch', urlfetch_mock):
-      cq_status.get_flaky_run_reason(fr_key)
-
-  def test_get_flaky_run_reason(self):
-    now = datetime.datetime.utcnow()
-    fr_key = self._create_flaky_run(now - datetime.timedelta(hours=1), now)
-
-    urlfetch_mock = mock.Mock()
-    urlfetch_mock.return_value.content = TEST_BUILDBOT_JSON_REPLY
-
-    # We also create one Flake to test that it is correctly updated. Other Flake
-    # entities will be created automatically.
-    Flake(id='bar5', name='bar5', occurrences=[],
-          last_time_seen=datetime.datetime.min).put()
-
-    with mock.patch('google.appengine.api.urlfetch.fetch', urlfetch_mock):
-      cq_status.get_flaky_run_reason(fr_key)
-
-    # Verify that we've used correct URL to access buildbot JSON endpoint.
-    urlfetch_mock.assert_called_once_with(
-        'http://build.chromium.org/p/test.master/json/builders/test-builder/'
-        'builds/100')
-
-    # Expected flakes to be found: list of (step_name, test_name).
-    expected_flakes = [
-        ('foo1', 'bar1'), ('foo2', 'TEST RESULTS WERE INVALID'),
-        ('foo3', 'bar2'), ('foo3', 'bar3'), ('foo4', 'bar5'), ('foo4', 'bar6'),
-        ('foo4', 'bar7'), ('foo8 (with patch)', 'bar13'),
-    ]
-
-    flake_occurrences = fr_key.get().flakes
-    print flake_occurrences
-    self.assertEqual(len(flake_occurrences), len(expected_flakes))
-    actual_flake_occurrences = [
-        (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, [fr_key])
-      self.assertEqual(flake.last_time_seen, now)
-      self.assertEqual(flake.count_hour, 1)
-      self.assertEqual(flake.count_day, 1)
-      self.assertEqual(flake.count_week, 1)
-      self.assertEqual(flake.count_month, 1)
-      self.assertEqual(flake.last_hour, True)
-      self.assertEqual(flake.last_day, True)
-      self.assertEqual(flake.last_week, True)
-      self.assertEqual(flake.last_month, True)
-
   def _mock_response(self, content):
     m = mock.Mock()
     if isinstance(content, basestring):
       m.content = content
     else:
       m.content = json.dumps(content)
     return m
 
   def test_fetch_cq_status_handles_and_retries_non_json_replies(self):
     urlfetch_mock = mock.Mock()
@@ skipping 131 matching lines @@
 
     self.assertEqual(urlfetch_mock.call_count, 3)
 
   def test_cq_status_fetch_detects_flaky_runs_correctly(self):
     urlfetch_mock = mock.Mock()
     urlfetch_mock.return_value.content = TEST_CQ_STATUS_RESPONSE
 
     with mock.patch('google.appengine.api.urlfetch.fetch', urlfetch_mock):
       cq_status.fetch_cq_status()
 
-    flaky_runs = FlakyRun.query().fetch(100)
-    self.assertEqual(len(flaky_runs), 3)
+    tasks = self.taskqueue_stub.get_filtered_tasks(queue_names='issue-updates')
+    self.assertEqual(len(tasks), 3)
 
-    # We only compare select few properties of the created FlakyRun entities.
-    flaky_run_tuples = set()
-    for flaky_run in flaky_runs:
-      failure_run = flaky_run.failure_run.get()
-      success_run = flaky_run.success_run.get()
+    # We only compare select few properties of the created BuildRun entities.
+    build_run_tuples = set()
+    for task in tasks:
+      params = task.extract_params()
+      failure_run = ndb.Key(urlsafe=params['failure_run_key']).get()
+      success_run = ndb.Key(urlsafe=params['success_run_key']).get()
       self.assertEqual(failure_run.key.parent(), success_run.key.parent())
       pbr = failure_run.key.parent().get()
-      flaky_run_tuple = (pbr.master, pbr.builder, pbr.issue, pbr.patchset,
+      build_run_tuple = (pbr.master, pbr.builder, pbr.issue, pbr.patchset,
                          failure_run.buildnumber, success_run.buildnumber)
-      flaky_run_tuples.add(flaky_run_tuple)
+      build_run_tuples.add(build_run_tuple)
 
-    expected_flaky_runs = set([
+    expected_build_runs = set([
       ('tryserver.test', 'test-builder', 987654321, 20001, 105, 110),
       ('tryserver.test', 'test-builder', 123456789, 20001, 109, 101),
       ('tryserver.test', 'test-builder', 123456789, 20001, 106, 101),
     ])
-    self.assertEqual(flaky_run_tuples, expected_flaky_runs)
+    self.assertEqual(build_run_tuples, expected_build_runs)
 
-  def test_cq_status_fetch_creates_deferred_tasks_correctly(self):
+  def test_cq_status_fetch_creates_tasks_correctly(self):
     urlfetch_mock = mock.Mock()
     urlfetch_mock.return_value.content = TEST_CQ_STATUS_RESPONSE
 
     with mock.patch('google.appengine.api.urlfetch.fetch', urlfetch_mock):
       cq_status.fetch_cq_status()
 
-    tasks = self.taskqueue_stub.get_filtered_tasks()
+    tasks = self.taskqueue_stub.get_filtered_tasks(queue_names='issue-updates')
     self.assertEqual(len(tasks), 3)
+    self.assertEqual(tasks[0].url, '/issues/create_flaky_run')
+    self.assertEqual(tasks[1].url, '/issues/create_flaky_run')
+    self.assertEqual(tasks[2].url, '/issues/create_flaky_run')
 
   def test_cq_status_processes_timestamp_in_raw_json(self):
     urlfetch_mock = mock.Mock()
     urlfetch_mock.return_value.content = (
         '{"more":false,"cursor":"","results":[],"timestamp":"foo"}')
 
     with mock.patch('google.appengine.api.urlfetch.fetch', urlfetch_mock):
       with mock.patch('logging.info') as logging_info_mock:
         cq_status.fetch_cq_status()
         logging_info_mock.assert_any_call(' current fetch has time of foo')