[Predator] Add CrashData class to process raw json crash data.

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.
 
 import mock
 
 from common import chrome_dependency_fetcher
 from common.dependency import DependencyRoll
 from crash import chromecrash_parser
 from crash import detect_regression_range
 from crash import findit
 from crash import findit_for_chromecrash
 from crash.changelist_classifier import ChangelistClassifier
 from crash.chromecrash_parser import ChromeCrashParser
 from crash.component_classifier import ComponentClassifier
 from crash.crash_report import CrashReport
 from crash.culprit import Culprit
 from crash.findit_for_chromecrash import FinditForChromeCrash
 from crash.findit_for_chromecrash import FinditForFracas
 from crash.project_classifier import ProjectClassifier
 from crash.suspect import Suspect
 from crash.stacktrace import CallStack
 from crash.stacktrace import Stacktrace
-from crash.test.crash_pipeline_test import DummyCrashData
 from crash.test.predator_testcase import PredatorTestCase
 from crash.type_enums import CrashClient
 from gae_libs.http.http_client_appengine import HttpClientAppengine
 from libs.gitiles.gitiles_repository import GitilesRepository
 from model import analysis_status
 from model.crash.crash_analysis import CrashAnalysis
 from model.crash.fracas_crash_analysis import FracasCrashAnalysis
 
 MOCK_GET_REPOSITORY = lambda _: None # pragma: no cover
 
@@ skipping 57 matching lines @@
         _FinditForChromeCrash(GitilesRepository.Factory(HttpClientAppengine())))
     self.assertIsNone(findit_client.FindCulprit(analysis))
 
 
 class FinditForFracasTest(PredatorTestCase):
 
   def testPlatformRename(self):
     self.assertEqual(_FinditForFracas().RenamePlatform('linux'), 'unix')
 
   def testCheckPolicyUnsupportedPlatform(self):
-    self.assertIsNone(_FinditForFracas().CheckPolicy(DummyCrashData(
+    self.assertIsNone(_FinditForFracas().CheckPolicy(self.GetDummyCrashData(
         platform = 'unsupported_platform')))
 
   def testCheckPolicyBlacklistedSignature(self):
-    self.assertIsNone(_FinditForFracas().CheckPolicy(DummyCrashData(
+    self.assertIsNone(_FinditForFracas().CheckPolicy(self.GetDummyCrashData(
         signature = 'Blacklist marker signature')))
 
   def testCheckPolicyPlatformRename(self):
-    new_crash_data = _FinditForFracas().CheckPolicy(DummyCrashData(
+    new_crash_data = _FinditForFracas().CheckPolicy(self.GetDummyCrashData(
         platform = 'linux'))
     self.assertIsNotNone(new_crash_data,
         'FinditForFracas.CheckPolicy unexpectedly returned None')
     self.assertEqual(new_crash_data['platform'], 'unix')
 
   def testCreateAnalysis(self):
     self.assertIsNotNone(_FinditForFracas().CreateAnalysis(
         {'signature': 'sig'}))
 
   def testGetAnalysis(self):
     crash_identifiers = {'signature': 'sig'}
     # TODO(wrengr): would be less fragile to call
     # FinditForFracas.CreateAnalysis instead.
     analysis = FracasCrashAnalysis.Create(crash_identifiers)
     analysis.put()
     self.assertEqual(_FinditForFracas().GetAnalysis(crash_identifiers),
                      analysis)
 
   def testInitializeAnalysisForFracas(self):
-    crash_data = DummyCrashData(platform = 'linux')
+    crash_data = self.GetDummyCrashData(platform = 'linux')
     crash_identifiers = crash_data['crash_identifiers']
 
     findit_client = _FinditForFracas()
     analysis = findit_client.CreateAnalysis(crash_identifiers)
     findit_client._InitializeAnalysis(analysis, crash_data)
     analysis.put()
     analysis = findit_client.GetAnalysis(crash_identifiers)
     self.assertIsNotNone(analysis,
         'FinditForFracas.GetAnalysis unexpectedly returned None')
 
-    self.assertEqual(analysis.crashed_version, crash_data['crashed_version'])
+    self.assertEqual(analysis.crashed_version, crash_data['chrome_version'])
     self.assertEqual(analysis.signature, crash_data['signature'])
     self.assertEqual(analysis.platform, crash_data['platform'])
     self.assertEqual(analysis.stack_trace, crash_data['stack_trace'])
     channel = crash_data['customized_data'].get('channel', None)
     self.assertIsNotNone(channel,
         'channel is unexpectedly not defined in crash_data')
     self.assertEqual(analysis.channel, channel)
 
   def testNeedsNewAnalysisIsTrueIfNoAnalysisYet(self):
-    self.assertTrue(_FinditForFracas()._NeedsNewAnalysis(DummyCrashData()))
+    self.assertTrue(_FinditForFracas()._NeedsNewAnalysis(
+        self.GetDummyCrashData()))
 
   def testNeedsNewAnalysisIsTrueIfLastOneFailed(self):
     findit_client = _FinditForFracas()
-    crash_data = DummyCrashData()
+    crash_data = self.GetDummyCrashData()
     analysis = findit_client.CreateAnalysis(crash_data['crash_identifiers'])
     analysis.status = analysis_status.ERROR
     analysis.put()
     self.assertTrue(findit_client._NeedsNewAnalysis(crash_data))
 
   def testNeedsNewAnalysisIsFalseIfLastOneIsNotFailed(self):
     findit_client = _FinditForFracas()
-    crash_data = DummyCrashData()
+    crash_data = self.GetDummyCrashData()
     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 testFindCulpritForChromeCrashEmptyStacktrace(self):
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
@@ skipping 109 matching lines @@
             'feedback_url': (
                 findit_for_chromecrash._FRACAS_FEEDBACK_URL_TEMPLATE % (
                     mocked_host, urlsafe_key)),
             'other': 'data'
         }
     }
 
     self.assertDictEqual(findit_object.GetPublishableResult(crash_identifiers,
                                                             analysis),
                          expected_processed_suspect)