Remove ReferenceResolver dependency in APIDataSource.

chrome/common/extensions/docs/server2/api_data_source_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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 json
 import os
 import sys
 import unittest
 
 from api_data_source import (_JSCModel,
                              _FormatValue,
                              _GetEventByNameFromEvents)
 from branch_utility import ChannelInfo
 from extensions_paths import CHROME_EXTENSIONS
 from fake_host_file_system_provider import FakeHostFileSystemProvider
 from features_bundle import FeaturesBundle
 from file_system import FileNotFoundError
 from future import Future
 from object_store_creator import ObjectStoreCreator
-from reference_resolver import ReferenceResolver
 from server_instance import ServerInstance
 from test_data.canned_data import (CANNED_API_FILE_SYSTEM_DATA, CANNED_BRANCHES)
 from test_data.api_data_source.canned_trunk_fs import CANNED_TRUNK_FS_DATA
 from test_file_system import TestFileSystem
 from test_util import Server2Path
 from third_party.json_schema_compiler.memoize import memoize
 
 
 def _MakeLink(href, text):
   return '<a href="%s">%s</a>' % (href, text)
@@ skipping 67 matching lines @@
             CANNED_API_FILE_SYSTEM_DATA))
     self._avail_api_models = server_instance.api_models
     self._avail_json_cache = server_instance.compiled_fs_factory.ForJson(
         server_instance.host_file_system_provider.GetTrunk())
     self._avail_finder = server_instance.availability_finder
 
   def _ReadLocalFile(self, filename):
     with open(os.path.join(self._base_path, filename), 'r') as f:
       return f.read()
 
-  def _CreateRefResolver(self, filename):
-    test_data = self._LoadJSON(filename)
-    return ReferenceResolver.Factory(_FakeAPIDataSource(test_data),
-                                     _FakeAPIModels(test_data),
-                                     ObjectStoreCreator.ForTest()).Create()
-
   def _LoadJSON(self, filename):
     return json.loads(self._ReadLocalFile(filename))
 
   def testCreateId(self):
     dict_ = _JSCModel('tester',
                       self._api_models,
-                      self._CreateRefResolver('test_file_data_source.json'),
                       False,
                       _FakeAvailabilityFinder(),
                       self._json_cache,
                       _FakeTemplateCache(),
                       self._features_bundle,
                       None).ToDict()
     self.assertEquals('type-TypeA', dict_['types'][0]['id'])
     self.assertEquals('property-TypeA-b',
                       dict_['types'][0]['properties'][0]['id'])
     self.assertEquals('method-get', dict_['functions'][0]['id'])
     self.assertEquals('event-EventA', dict_['events'][0]['id'])
 
   # TODO(kalman): re-enable this when we have a rebase option.
   def DISABLED_testToDict(self):
     expected_json = self._LoadJSON('expected_tester.json')
     dict_ = _JSCModel('tester',
                       self._api_models,
                       False,
-                      self._CreateRefResolver('test_file_data_source.json'),
                       _FakeAvailabilityFinder(),
                       self._json_cache,
                       _FakeTemplateCache(),
                       self._features_bundle,
                       None).ToDict()
     self.assertEquals(expected_json, dict_)
 
   def testFormatValue(self):
     self.assertEquals('1,234,567', _FormatValue(1234567))
     self.assertEquals('67', _FormatValue(67))
     self.assertEquals('234,567', _FormatValue(234567))
 
-  def testFormatDescription(self):
-    dict_ = _JSCModel('ref_test',
-                      self._api_models,
-                      self._CreateRefResolver('ref_test_data_source.json'),
-                      False,
-                      _FakeAvailabilityFinder(),
-                      self._json_cache,
-                      _FakeTemplateCache(),
-                      self._features_bundle,
-                      None).ToDict()
-    self.assertEquals(_MakeLink('ref_test.html#type-type2', 'type2'),
-                      _GetType(dict_, 'type1')['description'])
-    self.assertEquals(
-        'A %s, or %s' % (_MakeLink('ref_test.html#type-type3', 'type3'),
-                         _MakeLink('ref_test.html#type-type2', 'type2')),
-        _GetType(dict_, 'type2')['description'])
-    self.assertEquals(
-        '%s != %s' % (_MakeLink('other.html#type-type2', 'other.type2'),
-                      _MakeLink('ref_test.html#type-type2', 'type2')),
-        _GetType(dict_, 'type3')['description'])
-
-
   def testGetApiAvailability(self):
     api_availabilities = {
       'bluetooth': ChannelInfo('dev', CANNED_BRANCHES[28], 28),
       'contextMenus': ChannelInfo('trunk', CANNED_BRANCHES['trunk'], 'trunk'),
       'jsonStableAPI': ChannelInfo('stable', CANNED_BRANCHES[20], 20),
       'idle': ChannelInfo('stable', CANNED_BRANCHES[5], 5),
       'input.ime': ChannelInfo('stable', CANNED_BRANCHES[18], 18),
       'tabs': ChannelInfo('stable', CANNED_BRANCHES[18], 18)
     }
     for api_name, availability in api_availabilities.iteritems():
       model = _JSCModel(api_name,
                         self._avail_api_models,
-                        None,
                         True,
                         self._avail_finder,
                         self._avail_json_cache,
                         _FakeTemplateCache(),
                         self._features_bundle,
                         None)
       self.assertEquals(availability, model._GetApiAvailability())
 
   def testGetIntroList(self):
     model = _JSCModel('tester',
                       self._api_models,
-                      self._CreateRefResolver('test_file_data_source.json'),
                       False,
                       _FakeAvailabilityFinder(),
                       self._json_cache,
                       _FakeTemplateCache(),
                       self._features_bundle,
                       None)
     expected_list = [
       { 'title': 'Description',
         'content': [
           { 'text': 'a test api' }
@@ skipping 52 matching lines @@
     # Duplicates are an error.
     self.assertRaises(AssertionError, _GetEventByNameFromEvents, events)
 
   def _FakeLoadAddRulesSchema(self):
     events = self._LoadJSON('add_rules_def_test.json')
     return _GetEventByNameFromEvents(events)
 
   def testAddRules(self):
     dict_ = _JSCModel('add_rules_tester',
                       self._api_models,
-                      self._CreateRefResolver('test_file_data_source.json'),
                       False,
                       _FakeAvailabilityFinder(),
                       self._json_cache,
                       _FakeTemplateCache(),
                       self._features_bundle,
                       self._FakeLoadAddRulesSchema).ToDict()
 
     # Check that the first event has the addRulesFunction defined.
     self.assertEquals('add_rules_tester', dict_['name'])
     self.assertEquals('rules', dict_['events'][0]['name'])
     self.assertEquals('notable_name_to_check_for',
                       dict_['events'][0]['byName']['addRules'][
                           'parameters'][0]['name'])
 
     # Check that the second event has addListener defined.
     self.assertEquals('noRules', dict_['events'][1]['name'])
     self.assertEquals('add_rules_tester', dict_['name'])
     self.assertEquals('noRules', dict_['events'][1]['name'])
     self.assertEquals('callback',
                       dict_['events'][0]['byName']['addListener'][
                           'parameters'][0]['name'])
 
 if __name__ == '__main__':
   unittest.main()