[Findit] A huge refactoring and some bug fixing.

appengine/findit/waterfall/test/analyze_build_failure_pipeline_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 os
 
+from common import constants
 from common import chromium_deps
-from model import wf_analysis_status
+from model import analysis_status
 from model.wf_analysis import WfAnalysis
 from pipeline_wrapper import pipeline_handlers
 from waterfall import buildbot
 from waterfall import lock_util
 from waterfall.analyze_build_failure_pipeline import AnalyzeBuildFailurePipeline
 from waterfall.test import wf_testcase
 
 
 class AnalyzeBuildFailurePipelineTest(wf_testcase.WaterfallTestCase):
   app_module = pipeline_handlers._APP
@@ skipping 36 matching lines @@
     }
     """
     commit_log = COMMIT_LOG_TEMPLATE.replace(
         'REVISION', revision).replace('USER_NAME', user_name).replace(
             'COMMIT_POSITION', str(commit_position)).replace(
                 'FILE_PATH', file_path)
     urlfetch.register_handler(url, commit_log)
 
   def _Setup(self, master_name, builder_name, build_number):
     analysis = WfAnalysis.Create(master_name, builder_name, build_number)
-    analysis.status = wf_analysis_status.ANALYZING
+    analysis.status = analysis_status.RUNNING
     analysis.put()
 
     def MockWaitUntilDownloadAllowed(*_):
       return True
     self.mock(
         lock_util, 'WaitUntilDownloadAllowed', MockWaitUntilDownloadAllowed)
 
     with self.mock_urlfetch() as urlfetch:
       # Mock build data.
       for i in range(2):
@@ skipping 23 matching lines @@
     master_name = 'm'
     builder_name = 'b'
     build_number = 124
 
     self._Setup(master_name, builder_name, build_number)
 
     root_pipeline = AnalyzeBuildFailurePipeline(master_name,
                                                 builder_name,
                                                 build_number,
                                                 False)
-    root_pipeline.start(queue_name='default')
+    root_pipeline.start(queue_name=constants.DEFAULT_QUEUE)
     self.execute_queued_tasks()
 
     expected_analysis_result = {
         'failures': [
             {
                 'step_name': 'a',
                 'supported': True,
                 'first_failure': 124,
                 'last_pass': 123,
                 'suspected_cls': [
                     {
                         'build_number': 124,
                         'repo_name': 'chromium',
                         'revision': 'some_git_hash',
                         'commit_position': 8888,
                         'url': ('https://chromium.googlesource.com/chromium'
                                 '/src.git/+/some_git_hash'),
                         'score': 2,
                         'hints': {
                             'modified x.cc (and it was in log)': 2,
                         },
                     }
                 ],
             }
         ]
     }
 
     analysis = WfAnalysis.Get(master_name, builder_name, build_number)
     self.assertIsNotNone(analysis)
-    self.assertEqual(wf_analysis_status.ANALYZED, analysis.status)
+    self.assertEqual(analysis_status.COMPLETED, analysis.status)
     self.assertEqual(expected_analysis_result, analysis.result)
     self.assertIsNotNone(analysis.result_status)
 
   def testBuildFailurePipelineStartWithNoneResultStatus(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 124
 
     self._Setup(master_name, builder_name, build_number)
 
     root_pipeline = AnalyzeBuildFailurePipeline(master_name,
                                                 builder_name,
                                                 build_number,
                                                 False)
     root_pipeline._ResetAnalysis(master_name, builder_name, build_number)
     analysis = WfAnalysis.Get(master_name, builder_name, build_number)
     self.assertIsNotNone(analysis)
-    self.assertEqual(wf_analysis_status.ANALYZING, analysis.status)
+    self.assertEqual(analysis_status.RUNNING, analysis.status)
     self.assertIsNone(analysis.result_status)
 
   def testAnalyzeBuildFailurePipelineAbortedWithAnalysis(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 124
 
     self._Setup(master_name, builder_name, build_number)
 
     root_pipeline = AnalyzeBuildFailurePipeline(master_name,
                                                 builder_name,
                                                 build_number,
                                                 False)
     root_pipeline._LogUnexpectedAborting(True)
 
     analysis = WfAnalysis.Get(master_name, builder_name, build_number)
     self.assertIsNotNone(analysis)
-    self.assertEqual(wf_analysis_status.ERROR, analysis.status)
+    self.assertEqual(analysis_status.ERROR, analysis.status)
     self.assertIsNone(analysis.result_status)
 
   def testAnalyzeBuildFailurePipelineAbortedWithoutAnalysis(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 124
 
     root_pipeline = AnalyzeBuildFailurePipeline(master_name,
                                                 builder_name,
                                                 build_number,
@@ skipping 11 matching lines @@
     self._Setup(master_name, builder_name, build_number)
 
     root_pipeline = AnalyzeBuildFailurePipeline(master_name,
                                                 builder_name,
                                                 build_number,
                                                 False)
     root_pipeline._LogUnexpectedAborting(False)
 
     analysis = WfAnalysis.Get(master_name, builder_name, build_number)
     self.assertIsNotNone(analysis)
-    self.assertNotEqual(wf_analysis_status.ERROR, analysis.status)
+    self.assertNotEqual(analysis_status.ERROR, analysis.status)