[Findit] Display confidence score on result page.

appengine/findit/handlers/test/build_failure_test.py

 # Copyright 2014 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 os
 import re
 
 from google.appengine.ext import testbed
 
 import webapp2
 import webtest
 
+from common.waterfall import failure_type
 from handlers import build_failure
 from handlers import handlers_util
 from handlers import result_status
 from model import analysis_approach_type
 from model import analysis_status
 from model import suspected_cl_status
 from model.base_build_model import BaseBuildModel
+from model.suspected_cl_confidence import ConfidenceInformation
+from model.suspected_cl_confidence import SuspectedCLConfidence
 from model.wf_analysis import WfAnalysis
 from model.wf_suspected_cl import WfSuspectedCL
 from model.wf_try_job import WfTryJob
 from waterfall import buildbot
 from waterfall.test import wf_testcase
 
 # Root directory appengine/findit.
 ROOT_DIR = os.path.join(os.path.dirname(__file__),
                         os.path.pardir, os.path.pardir)
 
@@ skipping 72 matching lines @@
                         'revision': 'rev2',
                         'commit_position': '2',
                         'review_url': 'url_2'
                     }
                 }
             ]
         }
     }
 }
 
+SAMPLE_HEURISTIC_1 = ConfidenceInformation(
+    correct=100, total=100, confidence=1.0, score=5)
+
+SAMPLE_HEURISTIC_2 = ConfidenceInformation(
+    correct=90, total=100, confidence=0.9, score=4)
+
+SAMPLE_TRY_JOB = ConfidenceInformation(
+    correct=99, total=100, confidence=0.99, score=None)
+
+SAMPLE_HEURISTIC_TRY_JOB = ConfidenceInformation(
+    correct=98, total=100, confidence=0.98, score=None)
+
 
 class BuildFailureTest(wf_testcase.WaterfallTestCase):
   app_module = webapp2.WSGIApplication([
       ('/build-failure', build_failure.BuildFailure),
   ], debug=True)
 
   def setUp(self):
     super(BuildFailureTest, self).setUp()
 
     # Setup clean task queues.
     self.testbed.init_taskqueue_stub(root_path=ROOT_DIR)
     self.taskqueue_stub = self.testbed.get_stub(testbed.TASKQUEUE_SERVICE_NAME)
     for queue in self.taskqueue_stub.GetQueues():
       self.taskqueue_stub.FlushQueue(queue['name'])
 
     def MockedGetAllTryJobResults(master_name, builder_name, build_number, _):
       build_key = BaseBuildModel.CreateBuildId(
           master_name, builder_name, build_number)
       return SAMPLE_TRY_JOB_INFO.get(build_key, None)
     self.mock(handlers_util, 'GetAllTryJobResults', MockedGetAllTryJobResults)
 
+    self.cl_confidences = SuspectedCLConfidence.Create()
+    self.cl_confidences.compile_heuristic = [
+        SAMPLE_HEURISTIC_1, SAMPLE_HEURISTIC_2]
+    self.cl_confidences.test_heuristic = [
+        SAMPLE_HEURISTIC_2, SAMPLE_HEURISTIC_1]
+    self.cl_confidences.compile_try_job = SAMPLE_TRY_JOB
+    self.cl_confidences.test_try_job = SAMPLE_TRY_JOB
+    self.cl_confidences.compile_heuristic_try_job = SAMPLE_HEURISTIC_TRY_JOB
+    self.cl_confidences.test_heuristic_try_job = SAMPLE_HEURISTIC_TRY_JOB
+    self.cl_confidences.Save()
+
   def testGetTriageHistoryWhenUserIsNotAdmin(self):
     analysis = WfAnalysis.Create('m', 'b', 1)
     analysis.status = analysis_status.COMPLETED
     analysis.triage_history = [
         {
             'triage_timestamp': 1438380761,
             'user_name': 'test',
             'result_status': 'dummy status',
             'version': 'dummy version',
         }
@@ skipping 652 matching lines @@
                     'revision': 'rev',
                 }
             }
         }
     ]
     try_job.put()
 
     suspected_cl = WfSuspectedCL.Create('chromium', 'rev', 122)
     suspected_cl.builds = {
         'm/b/123': {
-            'failure_type': 'compile',
+            'failure_type': failure_type.COMPILE,
             'failures': None,
             'status': suspected_cl_status.CORRECT,
-            'approach': analysis_approach_type.HEURISTIC,
-            'top_score': 5,
-            'Confidence': 97.9
+            'approaches': [analysis_approach_type.HEURISTIC,
+                           analysis_approach_type.TRY_JOB],
+            'top_score': 5
         }
     }
     suspected_cl.put()
 
     expected_try_job_result = {
         'status': 'completed',
         'url': 'build/url',
         'completed': True,
         'culprit': {
             'revision': 'rev',
         },
         'failed': False,
     }
 
     expected_suspected_cls = [
         {
             'repo_name': 'chromium',
             'revision': 'rev',
             'commit_position': 122,
             'url': None,
-            'status': suspected_cl_status.CORRECT
+            'status': suspected_cl_status.CORRECT,
+            'confidence': build_failure._PercentFormat(
+                self.cl_confidences.compile_heuristic_try_job.confidence)
         }
     ]
 
     build_url = buildbot.CreateBuildUrl('m', 'b', 123)
     response = self.test_app.get('/build-failure',
                                  params={'url': build_url, 'format': 'json'})
 
     self.assertEquals(200, response.status_int)
     self.assertEqual(expected_try_job_result, response.json_body['try_job'])
     self.assertEqual(
         expected_suspected_cls, response.json_body['suspected_cls'])
 
   def testGetAllSuspectedCLsAndCheckStatus(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 123
     analysis = WfAnalysis.Create(master_name, builder_name, build_number)
     analysis.suspected_cls = [
         {
             'repo_name': 'chromium',
             'revision': 'rev',
             'commit_position': 122,
             'url': None
         }
     ]
     analysis.put()
     suspected_cl = WfSuspectedCL.Create('chromium', 'rev', 122)
     suspected_cl.builds = {
         'm/b/122': {
-            'failure_type': 'compile',
+            'failure_type': failure_type.COMPILE,
             'failures': None,
             'status': suspected_cl_status.CORRECT,
-            'approach': analysis_approach_type.HEURISTIC,
-            'top_score': 5,
-            'Confidence': 97.9
+            'approaches': [analysis_approach_type.TRY_JOB],
+            'top_score': 5
         }
     }
     suspected_cl.put()
 
     expected_suspected_cls = [
         {
             'repo_name': 'chromium',
             'revision': 'rev',
             'commit_position': 122,
             'url': None,
-            'status': None
+            'status': None,
+            'confidence': None
         }
     ]
 
     suspected_cls = build_failure._GetAllSuspectedCLsAndCheckStatus(
         master_name, builder_name, build_number, analysis)
     self.assertEqual(
         expected_suspected_cls, suspected_cls)
 
+  def testGetConfidenceScoreTestHeuristic(self):
+    build = {
+        'failure_type': failure_type.TEST,
+        'failures': None,
+        'status': suspected_cl_status.CORRECT,
+        'approaches': [analysis_approach_type.HEURISTIC],
+        'top_score': 5
+    }
+
+    self.assertEqual(
+        build_failure._PercentFormat(
+            self.cl_confidences.test_heuristic[1].confidence),
+        build_failure._GetConfidenceScore(self.cl_confidences, build))
+
+  def testGetConfidenceScoreCompileHeuristic(self):
+    build = {
+        'failure_type': failure_type.COMPILE,
+        'failures': None,
+        'status': suspected_cl_status.CORRECT,
+        'approaches': [analysis_approach_type.HEURISTIC],
+        'top_score': 4
+    }
+
+    self.assertEqual(
+        build_failure._PercentFormat(
+            self.cl_confidences.compile_heuristic[1].confidence),
+        build_failure._GetConfidenceScore(self.cl_confidences, build))
+
+  def testGetConfidenceScoreTestTryJob(self):
+    build = {
+        'failure_type': failure_type.TEST,
+        'failures': None,
+        'status': suspected_cl_status.CORRECT,
+        'approaches': [analysis_approach_type.TRY_JOB],
+        'top_score': 5
+    }
+
+    self.assertEqual(
+        build_failure._PercentFormat(
+            self.cl_confidences.test_try_job.confidence),
+        build_failure._GetConfidenceScore(self.cl_confidences, build))
+
+  def testGetConfidenceScoreCompileTryJob(self):
+    build = {
+        'failure_type': failure_type.COMPILE,
+        'failures': None,
+        'status': suspected_cl_status.CORRECT,
+        'approaches': [analysis_approach_type.TRY_JOB],
+        'top_score': 5
+    }
+
+    self.assertEqual(
+        build_failure._PercentFormat(
+            self.cl_confidences.test_try_job.confidence),
+        build_failure._GetConfidenceScore(self.cl_confidences, build))
+
+  def testGetConfidenceScoreTestHeuristicTryJob(self):
+    build = {
+        'failure_type': failure_type.TEST,
+        'failures': None,
+        'status': suspected_cl_status.CORRECT,
+        'approaches': [analysis_approach_type.HEURISTIC,
+                       analysis_approach_type.TRY_JOB],
+        'top_score': 5
+    }
+
+    self.assertEqual(
+        build_failure._PercentFormat(
+            self.cl_confidences.test_heuristic_try_job.confidence),
+        build_failure._GetConfidenceScore(self.cl_confidences, build))
+
+  def testGetConfidenceScoreNone(self):
+    self.assertIsNone(build_failure._GetConfidenceScore(None, None))
+
+  def testGetConfidenceScoreUnexpected(self):
+    build = {
+        'failure_type': failure_type.COMPILE,
+        'failures': None,
+        'status': suspected_cl_status.CORRECT,
+        'approaches': [analysis_approach_type.HEURISTIC],
+        'top_score': 2
+    }
+
+    self.assertIsNone(build_failure._GetConfidenceScore(
+        self.cl_confidences, build))
+
+  def testGetConfidenceScoreCompileNone(self):
+    build = {
+      'failure_type': failure_type.COMPILE,
+      'approaches': []
+    }
+    self.assertIsNone(build_failure._GetConfidenceScore(
+        self.cl_confidences, build))
+
+  def testGetConfidenceScoreUnexpectedTest(self):
+    build = {
+        'failure_type': failure_type.TEST,
+        'failures': None,
+        'status': suspected_cl_status.CORRECT,
+        'approaches': [analysis_approach_type.HEURISTIC],
+        'top_score': 2
+    }
+
+    self.assertIsNone(build_failure._GetConfidenceScore(
+        self.cl_confidences, build))
+
+  def testGetConfidenceScoreTestNone(self):
+    build = {
+      'failure_type': failure_type.TEST,
+      'approaches': []
+    }
+    self.assertIsNone(build_failure._GetConfidenceScore(
+        self.cl_confidences, build))
+
+  def testPercentFormatNone(self):
+    self.assertIsNone(build_failure._PercentFormat(None))