[Findit] Flake Checker: Extract commit position and git hash and display to UI for each analyzed bu…

appengine/findit/handlers/flake/test/check_flake_test.py

 # Copyright 2016 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 mock
 import re
 
 import webapp2
 import webtest
@@ skipping 53 matching lines @@
         self.test_app.get,
         '/waterfall/flake',
         params={
             'master_name': master_name,
             'builder_name': builder_name,
             'build_number': build_number,
             'step_name': step_name,
             'test_name': test_name
         })
 
-  def testAnyoneCanViewScheduledAnalysis(self):
+  @mock.patch.object(check_flake, '_GetSuspectedFlakeInfo',
+                     return_value={
+                         'build_number': 100,
+                         'commit_position': 12345,
+                         'git_hash': 'a_git_hash',
+                         'triage_result': 0})
+  @mock.patch.object(check_flake, '_GetCoordinatesData',
+                     return_value=[[100, 0.9, '1', 12345, 'a_git_hash']])
+  def testAnyoneCanViewScheduledAnalysis(self, *_):
     master_name = 'm'
     builder_name = 'b'
     build_number = '123'
     step_name = 's'
     test_name = 't'
     success_rate = .9
 
     analysis = MasterFlakeAnalysis.Create(
         master_name, builder_name, build_number, step_name, test_name)
     data_point = DataPoint()
     data_point.build_number = int(build_number)
     data_point.pass_rate = success_rate
     data_point.task_id = '1'
     analysis.data_points.append(data_point)
     analysis.status = analysis_status.COMPLETED
     analysis.suspected_flake_build_number = 100
     analysis.request_time = datetime.datetime(2016, 10, 01, 12, 10, 00)
     analysis.start_time = datetime.datetime(2016, 10, 01, 12, 10, 05)
     analysis.end_time = datetime.datetime(2016, 10, 01, 13, 10, 00)
     analysis.algorithm_parameters = {'iterations_to_rerun': 100}
     analysis.Save()
 
     response = self.test_app.get('/waterfall/flake', params={
         'key': analysis.key.urlsafe(),
         'format': 'json'})
 
     expected_check_flake_result = {
         'key': analysis.key.urlsafe(),
-        'pass_rates': [[int(build_number), success_rate, data_point.task_id]],
+        'pass_rates': [[100, 0.9, data_point.task_id, 12345, 'a_git_hash']],
         'analysis_status': STATUS_TO_DESCRIPTION.get(analysis.status),
         'master_name': master_name,
         'builder_name': builder_name,
         'build_number': int(build_number),
         'step_name': step_name,
         'test_name': test_name,
         'request_time': '2016-10-01 12:10:00 UTC',
         'task_number': 1,
         'error': None,
         'iterations_to_rerun': 100,
         'pending_time': '00:00:05',
         'duration': '00:59:55',
         'suspected_flake': {
             'build_number': 100,
+            'commit_position': 12345,
+            'git_hash': 'a_git_hash',
             'triage_result': 0
         },
         'version_number': 1,
         'show_debug_info': False
     }
 
     self.assertEquals(200, response.status_int)
     self.assertEqual(expected_check_flake_result, response.json_body)
 
   def testUnauthorizedUserCannotScheduleNewAnalysis(self):
@@ skipping 11 matching lines @@
         params={
             'master_name': master_name,
             'builder_name': builder_name,
             'build_number': build_number,
             'step_name': step_name,
             'test_name': test_name,
             'format': 'json'})
 
   @mock.patch.object(flake_analysis_service, 'ScheduleAnalysisForFlake',
                      return_value=False)
-  def testRequestExistingAnalysis(self, _):
+  @mock.patch.object(check_flake, '_GetSuspectedFlakeInfo',
+                     return_value={
+                         'build_number': 100,
+                         'commit_position': 12345,
+                         'git_hash': 'a_git_hash',
+                         'triage_result': 0})
+  @mock.patch.object(check_flake, '_GetCoordinatesData',
+                     return_value=[[100, 0.9, 'url', 12345, 'a_git_hash']])
+  def testRequestExistingAnalysis(self, *_):
     master_name = 'm'
     builder_name = 'b'
     build_number = 123
     step_name = 's'
     test_name = 't'
     success_rate = 0.9
 
     previous_analysis = MasterFlakeAnalysis.Create(
         master_name, builder_name, build_number - 1, step_name, test_name)
     data_point = DataPoint()
@@ skipping 22 matching lines @@
     response = self.test_app.get('/waterfall/flake', params={
         'master_name': master_name,
         'builder_name': builder_name,
         'build_number': build_number,
         'step_name': step_name,
         'test_name': test_name,
         'format': 'json'})
 
     expected_check_flake_result = {
         'key': previous_analysis.key.urlsafe(),
-        'pass_rates': [[build_number - 1, success_rate, None]],
+        'pass_rates': [[100, 0.9, 'url', 12345, 'a_git_hash']],
         'analysis_status': STATUS_TO_DESCRIPTION.get(previous_analysis.status),
         'master_name': master_name,
         'builder_name': builder_name,
         'build_number': build_number - 1,
         'step_name': step_name,
         'test_name': test_name,
         'request_time': '2016-10-01 12:10:00 UTC',
         'task_number': 1,
         'error': None,
         'iterations_to_rerun': 100,
         'pending_time': '00:00:05',
         'duration': '00:59:55',
         'suspected_flake': {
             'build_number': 100,
+            'commit_position': 12345,
+            'git_hash': 'a_git_hash',
             'triage_result': 0
         },
         'version_number': 1,
         'show_debug_info': False
     }
 
     self.assertEqual(200, response.status_int)
     self.assertEqual(expected_check_flake_result, response.json_body)
 
   @mock.patch.object(flake_analysis_service, 'ScheduleAnalysisForFlake',
@@ skipping 17 matching lines @@
         self.test_app.get,
         '/waterfall/flake',
         params={
             'master_name': master_name,
             'builder_name': builder_name,
             'build_number': build_number,
             'step_name': step_name,
             'test_name': test_name,
             'format': 'json'})
 
+  @mock.patch.object(check_flake, '_GetSuspectedFlakeInfo',
+                     return_value={
+                         'build_number': 100,
+                         'commit_position': 12345,
+                         'git_hash': 'a_git_hash',
+                         'triage_result': 0})
+  @mock.patch.object(check_flake, '_GetCoordinatesData',
+                     return_value=[[100, 0.9, 'url', 12345, 'a_git_hash']])
   @mock.patch.object(users, 'is_current_user_admin', return_value=True)
-  def testGetTriageHistory(self, _):
+  def testGetTriageHistory(self, *_):
     master_name = 'm'
     builder_name = 'b'
     build_number = '123'
     step_name = 's'
     test_name = 't'
     suspected_flake_build_number = 123
     triage_result = 2
     user_name = 'test'
 
     analysis = MasterFlakeAnalysis.Create(
@@ skipping 48 matching lines @@
             'm', 'b', '1', None, 't', '').get('data', {}).get('error_message'),
         'Step name must be specified')
     self.assertEqual(
         CheckFlake()._ValidateInput(
             'm', 'b', '1', 's', None, '').get('data', {}).get('error_message'),
         'Test name must be specified')
     self.assertEqual(
         CheckFlake()._ValidateInput(
             'm', 'b', '1', 's', 't', 'a').get('data', {}).get('error_message'),
         'Bug id (optional) must be an int')
+
+  def testGetSuspectedFlakeInfo(self):
+    analysis = MasterFlakeAnalysis.Create('m', 'b', 123, 's', 't')
+    analysis.suspected_flake_build_number = 123
+    data_point = DataPoint()
+    data_point.build_number = 123
+    data_point.pass_rate = 0.9
+    data_point.commit_position = 2
+    data_point.git_hash = 'git_hash_2'
+    data_point.previous_commit_position = 1
+    data_point.previous_git_hash = 'git_hash_1'
+    analysis.data_points.append(data_point)
+    analysis.Save()
+
+    expected_result = {
+        'build_number': analysis.suspected_flake_build_number,
+        'commit_position': 2,
+        'git_hash': 'git_hash_2',
+        'previous_commit_position': 1,
+        'previous_git_hash': 'git_hash_1',
+        'triage_result': 0
+    }
+    self.assertEqual(expected_result,
+                     check_flake._GetSuspectedFlakeInfo(analysis))
+
+  def testGetCoordinatesData(self):
+    master_name = 'm'
+    builder_name = 'b'
+    build_number = 123
+    step_name = 's'
+    test_name = 't'
+    success_rate = .9
+    analysis = MasterFlakeAnalysis.Create(
+        master_name, builder_name, build_number, step_name, test_name)
+    data_point = DataPoint()
+    data_point.build_number = build_number
+    data_point.pass_rate = success_rate
+    data_point.commit_position = 2
+    data_point.git_hash = 'git_hash_2'
+    data_point.previous_commit_position = 1
+    data_point.previous_git_hash = 'git_hash_1'
+    analysis.data_points.append(data_point)
+    analysis.Save()
+
+    self.assertEqual([[build_number, success_rate, None, 1, 2, 'git_hash_1',
+                       'git_hash_2']],
+                     check_flake._GetCoordinatesData(analysis))
+
+  def testFindSuspectedFlakeBuildDataPoint(self):
+    master_name = 'm'
+    builder_name = 'b'
+    build_number = 123
+    step_name = 's'
+    test_name = 't'
+    analysis = MasterFlakeAnalysis.Create(
+        master_name, builder_name, build_number, step_name, test_name)
+    analysis.suspected_flake_build_number = build_number
+    data_point_1 = DataPoint()
+    data_point_1.build_number = build_number - 1
+    data_point_1.pass_rate = 1
+    data_point_1.commit_position = 2
+    data_point_1.git_hash = 'git_hash_2'
+    data_point_1.previous_commit_position = 1
+    data_point_1.previous_git_hash = 'git_hash_1'
+    analysis.data_points.append(data_point_1)
+    data_point_2 = DataPoint()
+    data_point_2.build_number = build_number
+    data_point_2.pass_rate = 0.9
+    data_point_2.commit_position = 4
+    data_point_2.git_hash = 'git_hash_4'
+    data_point_2.previous_commit_position = 3
+    data_point_2.previous_git_hash = 'git_hash_3'
+    analysis.data_points.append(data_point_2)
+    analysis.Save()
+
+    self.assertEqual(data_point_2,
+                     check_flake._FindSuspectedFlakeBuildDataPoint(analysis))