Moving ScheduleNewAnalysis to break the cycle

appengine/findit/crash/test/findit_for_chromecrash_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.
 
 from common import chrome_dependency_fetcher
 from common.dependency import DependencyRoll
 from common.http_client_appengine import HttpClientAppengine
 from crash import chromecrash_parser
 from crash import detect_regression_range
 from crash import findit_for_chromecrash
@@ skipping 10 matching lines @@
 from crash.stacktrace import CallStack
 from crash.stacktrace import Stacktrace
 from crash.test.crash_pipeline_test import DummyCrashData
 from crash.test.crash_testcase import CrashTestCase
 from crash.type_enums import CrashClient
 from lib.gitiles import gitiles_repository
 from model import analysis_status
 from model.crash.crash_analysis import CrashAnalysis
 from model.crash.fracas_crash_analysis import FracasCrashAnalysis
 
-# In production we'd use CrashWrapperPipeline. And that'd work fine here,
-# since we never actually call the method that uses it. But just to be
-# absolutely sure we don't go over the wire due to some mocking failure,
-# we'll use this dummy class instead. (In fact, since it's never used,
-# we don't even need to give a real class; ``None`` works just fine.)
-MOCK_PIPELINE_CLS = None
-
 MOCK_REPOSITORY = None
 
 class _FinditForChromeCrash(FinditForChromeCrash):
   # We allow overriding the default MOCK_REPOSITORY because one unittest
   # needs to.
   def __init__(self, repository=MOCK_REPOSITORY):
-    super(_FinditForChromeCrash, self).__init__(repository, MOCK_PIPELINE_CLS)
+    super(_FinditForChromeCrash, self).__init__(repository)
 
   @classmethod
   def _ClientID(cls): # pragma: no cover
     """Avoid throwing a NotImplementedError.
 
     Since this method is called from ``FinditForChromeCrash.__init__``
     in order to construct the Azalea object, we need to not throw
     exceptions since we want to be able to test the FinditForChromeCrash
     class itself.
     """
     return ''
 
   @property
   def config(self):
     """Avoid returning None.
 
     The default ``Findit.config`` will return None if the client
     id is not found in the CrashConfig. This in turn will cause
     ``FinditForChromeCrash.__init__`` to crash, since NoneType doesn't
     have a ``get`` method. In general it's fine for things to crash, since
     noone should make instances of Findit subclasses which don't define
     ``_clientID``; but for this test suite, we want to permit instances
     of FinditForChromeCrash, so that we can test that class directly.
     """
     return {}
 
 def _FinditForFracas():
   """A helper to pass in the standard pipeline class."""
-  return FinditForFracas(MOCK_REPOSITORY, MOCK_PIPELINE_CLS)
+  return FinditForFracas(MOCK_REPOSITORY)
 
 
 class FinditForChromeCrashTest(CrashTestCase):
 
   chrome_dep_fetcher = chrome_dependency_fetcher.ChromeDependencyFetcher(
       gitiles_repository.GitilesRepository(http_client=HttpClientAppengine()))
 
   # TODO(wrengr): what was the purpose of this test? As written it's
   # just testing that mocking works. I'm guessing it was to check that
   # we fail when the analysis is for the wrong client_id; but if so,
@@ skipping 85 matching lines @@
     findit_client = _FinditForFracas()
     crash_data = DummyCrashData()
     crash_identifiers = crash_data['crash_identifiers']
     for status in (analysis_status.PENDING, analysis_status.RUNNING,
                    analysis_status.COMPLETED, analysis_status.SKIPPED):
       analysis = findit_client.CreateAnalysis(crash_identifiers)
       analysis.status = status
       analysis.put()
       self.assertFalse(findit_client._NeedsNewAnalysis(crash_data))
 
-  def testScheduleNewAnalysisSkipsUnsupportedChannel(self):
-    self.assertFalse(_FinditForFracas().ScheduleNewAnalysis(DummyCrashData(
-        version = None,
-        signature = None,
-        crash_identifiers = {},
-        channel = 'unsupported_channel')))
-
-  def testScheduleNewAnalysisSkipsUnsupportedPlatform(self):
-    self.assertFalse(_FinditForFracas().ScheduleNewAnalysis(DummyCrashData(
-        version = None,
-        signature = None,
-        platform = 'unsupported_platform',
-        crash_identifiers = {})))
-
-  def testScheduleNewAnalysisSkipsBlackListSignature(self):
-    self.assertFalse(_FinditForFracas().ScheduleNewAnalysis(DummyCrashData(
-        version = None,
-        signature = 'Blacklist marker signature',
-        crash_identifiers = {})))
-
-  def testScheduleNewAnalysisSkipsIfAlreadyCompleted(self):
-    findit_client = _FinditForFracas()
-    crash_data = DummyCrashData()
-    crash_identifiers = crash_data['crash_identifiers']
-    analysis = findit_client.CreateAnalysis(crash_identifiers)
-    analysis.status = analysis_status.COMPLETED
-    analysis.put()
-    self.assertFalse(findit_client.ScheduleNewAnalysis(crash_data))
-
   def testFindCulpritForChromeCrashEmptyStacktrace(self):
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependency', lambda *_: {})
     self.mock(ChromeCrashParser, 'Parse', lambda *_: Stacktrace())
 
     analysis = CrashAnalysis()
     analysis.signature = 'signature'
     analysis.platform = 'win'
     analysis.stack_trace = 'frame1\nframe2'
     analysis.crashed_version = '50.0.1234.0'
@@ skipping 70 matching lines @@
     expected_tag = {
           'found_suspects': False,
           'found_project': False,
           'found_components': False,
           'has_regression_range': False,
           'solution': 'core_algorithm',
     }
 
     self.assertDictEqual(expected_results, results)
     self.assertDictEqual(expected_tag, tag)