[Findit] Adding central config test class for unit tests

appengine/findit/waterfall/test/extract_signal_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 testing_utils import testing
-
 from model.wf_analysis import WfAnalysis
 from model.wf_step import WfStep
 from pipeline_wrapper import pipeline_handlers
 from waterfall import buildbot
 from waterfall import try_job_util
-from waterfall import waterfall_config
 from waterfall.extract_signal_pipeline import ExtractSignalPipeline
+from waterfall.test import wf_testcase
 
 
-class ExtractSignalPipelineTest(testing.AppengineTestCase):
+class ExtractSignalPipelineTest(wf_testcase.WaterfallTestCase):
   app_module = pipeline_handlers._APP
 
   def setUp(self):
     super(ExtractSignalPipelineTest, self).setUp()
 
     def Mocked_ScheduleTryJobIfNeeded(*_, **__):
       pass
     self.mock(
         try_job_util, 'ScheduleTryJobIfNeeded', Mocked_ScheduleTryJobIfNeeded)
 
@@ skipping 55 matching lines @@
     step_name = 'abc_test'
     step = WfStep.Create(master_name, builder_name, build_number, step_name)
     step.log_data = self.ABC_TEST_FAILURE_LOG
     step.put()
 
     step_log_url = buildbot.CreateStdioLogUrl(
         master_name, builder_name, build_number, step_name)
     with self.mock_urlfetch() as urlfetch:
       urlfetch.register_handler(step_log_url, 'If used, test should fail!')
 
-    def MockStepIsSupportedForMaster(*_):
-      return True
-    self.mock(waterfall_config, 'StepIsSupportedForMaster',
-              MockStepIsSupportedForMaster)
     self._CreateAndSaveWfAnanlysis(
         master_name, builder_name, build_number)
 
     pipeline = ExtractSignalPipeline(self.FAILURE_INFO)
     signals = pipeline.run(self.FAILURE_INFO, False)
 
     self.assertEqual(self.FAILURE_SIGNALS, signals)
 
   def MockGetStdiolog(self, master_name, builder_name, build_number, step_name):
     step_log_url = buildbot.CreateStdioLogUrl(
@@ skipping 86 matching lines @@
     build_number = 123
     step_name = 'abc_test'
 
     # Mock both stdiolog and gtest json results to test whether Findit will
     # go to step log first when both logs exist.
     self.MockGetStdiolog(master_name, builder_name, build_number, step_name)
     self.MockGetGtestJsonResult()
     self._CreateAndSaveWfAnanlysis(
         master_name, builder_name, build_number)
 
-    def MockStepIsSupportedForMaster(*_):
-      return True
-    self.mock(waterfall_config, 'StepIsSupportedForMaster',
-              MockStepIsSupportedForMaster)
-
     pipeline = ExtractSignalPipeline(self.FAILURE_INFO)
     signals = pipeline.run(self.FAILURE_INFO, False)
 
     step = WfStep.Get(master_name, builder_name, build_number, step_name)
 
     expected_files = {
         'a/b/u2s1.cc': [567],
         'a/b/u3s2.cc': [110]
     }
 
     self.assertIsNotNone(step)
     self.assertIsNotNone(step.log_data)
     self.assertEqual(expected_files, signals['abc_test']['files'])
 
   def testGetSignalFromStepLogFlaky(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 124
     step_name = 'abc_test'
 
     failure_info = {
-        'master_name': 'm',
-        'builder_name': 'b',
-        'build_number': 124,
+        'master_name': master_name,
+        'builder_name': builder_name,
+        'build_number': build_number,
         'failed': True,
         'chromium_revision': 'a_git_hash',
         'failed_steps': {
             'abc_test': {
                 'last_pass': 123,
                 'current_failure': 124,
                 'first_failure': 124,
             }
         }
     }
 
     self.MockGetStdiolog(master_name, builder_name, build_number, step_name)
     self.MockGetGtestJsonResult()
     self._CreateAndSaveWfAnanlysis(
         master_name, builder_name, build_number)
 
-    def MockStepIsSupportedForMaster(*_):
-      return True
-    self.mock(waterfall_config, 'StepIsSupportedForMaster',
-              MockStepIsSupportedForMaster)
-
     pipeline = ExtractSignalPipeline()
     signals = pipeline.run(failure_info, False)
 
     step = WfStep.Get(master_name, builder_name, build_number, step_name)
 
     self.assertIsNotNone(step)
     self.assertIsNotNone(step.log_data)
     self.assertEqual('flaky', step.log_data)
     self.assertEqual({}, signals['abc_test']['files'])
 
   def testGetSignalFromStepLogInvalid(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 125
     step_name = 'abc_test'
 
     failure_info = {
-        'master_name': 'm',
-        'builder_name': 'b',
-        'build_number': 125,
+        'master_name': master_name,
+        'builder_name': builder_name,
+        'build_number': build_number,
         'failed': True,
         'chromium_revision': 'a_git_hash',
         'failed_steps': {
-            'abc_test': {
+            step_name: {
                 'last_pass': 124,
                 'current_failure': 125,
                 'first_failure': 125,
             }
         }
     }
 
     self.MockGetStdiolog(master_name, builder_name, build_number, step_name)
     self.MockGetGtestJsonResult()
     self._CreateAndSaveWfAnanlysis(
         master_name, builder_name, build_number)
 
-    def MockStepIsSupportedForMaster(*_):
-      return True
-    self.mock(waterfall_config, 'StepIsSupportedForMaster',
-              MockStepIsSupportedForMaster)
-
     pipeline = ExtractSignalPipeline()
     signals = pipeline.run(failure_info, False)
 
     step = WfStep.Get(master_name, builder_name, build_number, step_name)
 
     expected_files = {
         'content/common/gpu/media/v4l2_video_encode_accelerator.cc': [306]
     }
 
     self.assertIsNotNone(step)
@@ skipping 81 matching lines @@
                 'Unittest3.Subtest2': {
                     'files': {
                         'a/b/u3s2.cc': [110, 123]
                     },
                     'keywords': {}
                 }
             }
         }
     }
 
-    def MockStepIsSupportedForMaster(*_):
-      return True
-    self.mock(waterfall_config, 'StepIsSupportedForMaster',
-              MockStepIsSupportedForMaster)
-
     self._CreateAndSaveWfAnanlysis(
         master_name, builder_name, build_number)
 
     pipeline = ExtractSignalPipeline()
     signals = pipeline.run(failure_info, False)
     self.assertEqual(expected_signals, signals)
 
   def testExtractSignalsForTestsFlaky(self):
     master_name = 'm'
     builder_name = 'b'
@@ skipping 32 matching lines @@
     step.put()
 
     expected_signals = {
         'abc_test': {
             'files': {},
             'keywords': {},
             'tests': {}
         }
     }
 
-    def MockStepIsSupportedForMaster(*_):
-      return True
-    self.mock(waterfall_config, 'StepIsSupportedForMaster',
-              MockStepIsSupportedForMaster)
     self._CreateAndSaveWfAnanlysis(
         master_name, builder_name, build_number)
 
     pipeline = ExtractSignalPipeline()
     signals = pipeline.run(failure_info, False)
     self.assertEqual(expected_signals, signals)
 
   def testBailOutForUnsupportedStep(self):
     master_name = 'm'
     builder_name = 'b'
     build_number = 123
     supported_step_name = 'abc_test'
+    unsupported_step_name = 'unsupported_step6'
     failure_info = {
         'master_name': master_name,
         'builder_name': 'b',
         'build_number': 123,
         'failed': True,
         'chromium_revision': 'a_git_hash',
         'failed_steps': {
             supported_step_name: {
                 'last_pass': 122,
                 'current_failure': 123,
                 'first_failure': 123,
             },
-            'not_supported': {
+            unsupported_step_name: {
             }
         }
     }
 
-    def MockStepIsSupportedForMaster(step_name, _):
-      return step_name == supported_step_name
-
     def MockGetGtestResultLog(*_):
       return None
 
-    self.mock(waterfall_config, 'StepIsSupportedForMaster',
-              MockStepIsSupportedForMaster)
     self.MockGetStdiolog(master_name, builder_name, build_number,
                          supported_step_name)
     self.mock(buildbot, 'GetGtestResultLog', MockGetGtestResultLog)
     self._CreateAndSaveWfAnanlysis(
         master_name, builder_name, build_number)
 
     pipeline = ExtractSignalPipeline()
     signals = pipeline.run(failure_info, False)
     self.assertEqual(self.FAILURE_SIGNALS, signals)