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

appengine/findit/handlers/crash/test/crash_handler_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 base64
 import copy
 import json
 import logging
 
 from google.appengine.api import app_identity
 from google.appengine.ext import ndb
 import webapp2
 from webtest.app import AppError
 
 from common import chrome_dependency_fetcher
 from crash import crash_pipeline
 from crash.findit import Findit
 from crash.findit_for_chromecrash import FinditForFracas
-from crash.test.crash_pipeline_test import DummyCrashData
 from crash.test.predator_testcase import PredatorTestCase
 from crash.type_enums import CrashClient
 from handlers.crash import crash_handler
 from libs.gitiles import gitiles_repository
 from model import analysis_status
 from model.crash.fracas_crash_analysis import FracasCrashAnalysis
 
 
 MOCK_GET_REPOSITORY = lambda _: None # pragma: no cover
 
@@ skipping 21 matching lines @@
 
       def CheckPolicy(self, crash_data):
         """This is the same as inherited, but just to be explicit."""
         return None
 
       def _NeedsNewAnalysis(self, _crash_data):
         raise AssertionError('testScheduleNewAnalysisWithFailingPolicy: '
             "called _MockFindit._NeedsNewAnalysis, when it shouldn't.")
 
     self.mock(crash_pipeline, 'FinditForClientID', lambda *_: _MockFindit())
-    self.assertFalse(crash_handler.ScheduleNewAnalysis(DummyCrashData(
+    self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = 'MOCK_CLIENT')))
 
   def testScheduleNewAnalysisWithPlatformRename(self):
-    original_crash_data = DummyCrashData(
+    original_crash_data = self.GetDummyCrashData(
         client_id = 'MOCK_CLIENT',
         version = None,
         platform = 'unix',
         crash_identifiers = {})
     renamed_crash_data = copy.deepcopy(original_crash_data)
     renamed_crash_data['platform'] = 'linux'
 
     testcase = self
     class _MockFindit(Findit): # pylint: disable=W0223
       def __init__(self):
@@ skipping 16 matching lines @@
       def _NeedsNewAnalysis(self, new_crash_data):
         logging.debug('Called _MockFindit._NeedsNewAnalysis, as desired')
         testcase.assertDictEqual(new_crash_data, renamed_crash_data)
         return False
 
     self.mock(crash_pipeline, 'FinditForClientID',
         lambda _client_id, repository: _MockFindit())
     self.assertFalse(crash_handler.ScheduleNewAnalysis(original_crash_data))
 
   def testScheduleNewAnalysisSkipsUnsupportedChannel(self):
-    self.assertFalse(crash_handler.ScheduleNewAnalysis(DummyCrashData(
+    self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = CrashClient.FRACAS,
         version = None,
         signature = None,
         crash_identifiers = {},
         channel = 'unsupported_channel')))
 
   def testScheduleNewAnalysisSkipsUnsupportedPlatform(self):
-    self.assertFalse(crash_handler.ScheduleNewAnalysis(DummyCrashData(
+    self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = CrashClient.FRACAS,
         version = None,
         signature = None,
         platform = 'unsupported_platform',
         crash_identifiers = {})))
 
   def testScheduleNewAnalysisSkipsBlackListSignature(self):
-    self.assertFalse(crash_handler.ScheduleNewAnalysis(DummyCrashData(
+    self.assertFalse(crash_handler.ScheduleNewAnalysis(self.GetDummyCrashData(
         client_id = CrashClient.FRACAS,
         version = None,
         signature = 'Blacklist marker signature',
         crash_identifiers = {})))
 
   def testScheduleNewAnalysisSkipsIfAlreadyCompleted(self):
     findit_client = FinditForFracas(MOCK_GET_REPOSITORY)
-    crash_data = DummyCrashData(client_id = findit_client.client_id)
+    crash_data = self.GetDummyCrashData(client_id = findit_client.client_id)
     crash_identifiers = crash_data['crash_identifiers']
     analysis = findit_client.CreateAnalysis(crash_identifiers)
     analysis.status = analysis_status.COMPLETED
     analysis.put()
     self.assertFalse(crash_handler.ScheduleNewAnalysis(crash_data))
 
   def testAnalysisScheduled(self):
     # We need to mock out the method on Findit itself (rather than using a
     # subclass), since this method only gets called on objects we
     # ourselves don't construct.
@@ skipping 100 matching lines @@
     self.mock(FinditForFracas, 'ParseStacktrace', _MockParseStacktrace)
 
     # More directly address the issue about ``GetChromeDependency`` going
     # over the wire.
     def _MockGetChromeDependency(_self, _revision, _platform):
       raise AssertionError("GetChromeDependency shouldn't ever be called. "
           'That it was indicates some sort of problem with our mocking code.')
     self.mock(chrome_dependency_fetcher.ChromeDependencyFetcher,
         'GetDependency', _MockGetChromeDependency)
 
-    crash_data = DummyCrashData(
+    crash_data = self.GetDummyCrashData(
         client_id = CrashClient.FRACAS,
         version = '50.2500.0.1',
         stack_trace = 'frame1\nframe2\nframe3')
     self.assertTrue(crash_handler.ScheduleNewAnalysis(crash_data))
 
     # The catch/re-raise is to clean up the callstack that's reported
     # when things acciddentally go over the wire (and subsequently fail).
     try:
       self.execute_queued_tasks()
     except AppError, e: # pragma: no cover
@@ skipping 15 matching lines @@
             'client_id': CrashClient.FRACAS,
             'result': processed_analysis_result,
         }, sort_keys=True)]
     self.assertListEqual(expected_messages_data, pubsub_publish_requests[0][0])
     self.assertEqual(1, len(analyzed_crashes))
     analysis = analyzed_crashes[0]
     self.assertTrue(isinstance(analysis, FracasCrashAnalysis))
     self.assertEqual(crash_data['signature'], analysis.signature)
     self.assertEqual(crash_data['platform'], analysis.platform)
     self.assertEqual(crash_data['stack_trace'], analysis.stack_trace)
-    self.assertEqual(crash_data['crashed_version'], analysis.crashed_version)
+    self.assertEqual(crash_data['chrome_version'], analysis.crashed_version)
     self.assertEqual(crash_data['regression_range'], analysis.regression_range)
 
     analysis = FracasCrashAnalysis.Get(crash_data['crash_identifiers'])
     self.assertEqual(analysis_result, analysis.result)
     return analysis
 
   def testRunningAnalysis(self):
     analysis_result = {
         'found': True,
         'suspected_cls': [],
@@ skipping 44 matching lines @@
         'has_regression_range': True,
         'solution': 'core',
         'unsupported_tag': '',
     }
 
     analysis = self._TestRunningAnalysisForResult(
         analysis_result, analysis_tags)
     self.assertTrue(analysis.has_regression_range)
     self.assertTrue(analysis.found_suspects)
     self.assertEqual('core', analysis.solution)