Docserver: separate models for apps and extensions

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
 
@@ skipping 19 matching lines @@
 def _MakeLink(href, text):
   return '<a href="%s">%s</a>' % (href, text)
 
 
 def _GetType(dict_, name):
   for type_ in dict_['types']:
     if type_['name'] == name:
       return type_
 
 
-class _FakeAvailabilityFinder(object):
-
-  def GetAPIAvailability(self, version):
-    return AvailabilityInfo(ChannelInfo('stable', '396', 5))
-
-
-class _FakeScheduledAvailabilityFinder(object):
-
-  def GetAPIAvailability(self, version):
-    return AvailabilityInfo(ChannelInfo('beta', '1453', 27), scheduled=28)
-
-
 class _FakeTemplateCache(object):
 
   def GetFromFile(self, key):
     return Future(value='handlebar %s' % key)
 
 
+class _FakeFeaturesBundle(object):
+  def GetAPIFeatures(self):
+    return Future(value={
+      'bluetooth': {'value': True},
+      'contextMenus': {'value': True},
+      'jsonStableAPI': {'value': True},
+      'idle': {'value': True},
+      'input.ime': {'value': True},
+      'tabs': {'value': True}
+    })
+
+
 class APIDataSourceTest(unittest.TestCase):
 
   def setUp(self):
     self._base_path = Server2Path('test_data', 'test_json')
 
     server_instance = ServerInstance.ForTest(
         TestFileSystem(CANNED_TRUNK_FS_DATA, relative_to=CHROME_EXTENSIONS))
     file_system = server_instance.host_file_system_provider.GetTrunk()
     self._json_cache = server_instance.compiled_fs_factory.ForJson(file_system)
     self._features_bundle = FeaturesBundle(file_system,
                                            server_instance.compiled_fs_factory,
-                                           server_instance.object_store_creator)
-    self._api_models = server_instance.api_models
+                                           server_instance.object_store_creator,
+                                           'extensions')
+    self._api_models = server_instance.platform_bundle.GetAPIModels(
+        'extensions')
+    self._fake_availability = AvailabilityInfo(ChannelInfo('stable', '396', 5))
 
     # Used for testGetAPIAvailability() so that valid-ish data is processed.
     server_instance = ServerInstance.ForTest(
         file_system_provider=FakeHostFileSystemProvider(
             CANNED_API_FILE_SYSTEM_DATA))
-    self._avail_api_models = server_instance.api_models
+    self._avail_api_models = server_instance.platform_bundle.GetAPIModels(
+        'extensions')
     self._avail_json_cache = server_instance.compiled_fs_factory.ForJson(
         server_instance.host_file_system_provider.GetTrunk())
-    self._avail_finder = server_instance.availability_finder
+    self._avail_finder = server_instance.platform_bundle.GetAvailabilityFinder(
+        'extensions')
 
   def _ReadLocalFile(self, filename):
     with open(os.path.join(self._base_path, filename), 'r') as f:
       return f.read()
 
   def _LoadJSON(self, filename):
     return json.loads(self._ReadLocalFile(filename))
 
   def testCreateId(self):
     dict_ = _JSCModel(self._api_models.GetModel('tester').Get(),
-                      _FakeAvailabilityFinder(),
+                      self._fake_availability,
                       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(self._api_models.GetModel('tester').Get(),
-                      _FakeAvailabilityFinder(),
+                      self._fake_availability,
                       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 testGetAPIAvailability(self):
     api_availabilities = {
-      'bluetooth': AvailabilityInfo(
-          ChannelInfo('dev', CANNED_BRANCHES[28], 28)),
-      'contextMenus': AvailabilityInfo(
-          ChannelInfo('trunk', CANNED_BRANCHES['trunk'], 'trunk')),
-      'jsonStableAPI': AvailabilityInfo(
-          ChannelInfo('stable', CANNED_BRANCHES[20], 20)),
-      'idle': AvailabilityInfo(
-          ChannelInfo('stable', CANNED_BRANCHES[5], 5)),
-      'input.ime': AvailabilityInfo(
-          ChannelInfo('stable', CANNED_BRANCHES[18], 18)),
-      'tabs': AvailabilityInfo(
-          ChannelInfo('stable', CANNED_BRANCHES[18], 18))
+      'bluetooth': 28,
+      'contextMenus': 'trunk',
+      'jsonStableAPI': 20,
+      'idle': 5,
+      'input.ime': 18,
+      'tabs': 18
     }
     for api_name, availability in api_availabilities.iteritems():
-      model = _JSCModel(self._avail_api_models.GetModel(api_name).Get(),
-                        self._avail_finder,
-                        self._avail_json_cache,
-                        _FakeTemplateCache(),
-                        self._features_bundle,
-                        None)
-      self.assertEquals(availability, model._GetAPIAvailability())
+      model_dict = _JSCModel(
+          self._avail_api_models.GetModel(api_name).Get(),
+          self._avail_finder.GetAPIAvailability(api_name),
+          self._avail_json_cache,
+          _FakeTemplateCache(),
+          _FakeFeaturesBundle(),
+          None).ToDict()
+      self.assertEquals(availability,
+                        model_dict['introList'][1]['content'][0]['version'])
 
   def testGetIntroList(self):
     model = _JSCModel(self._api_models.GetModel('tester').Get(),
-                      _FakeAvailabilityFinder(),
+                      self._fake_availability,
                       self._json_cache,
                       _FakeTemplateCache(),
                       self._features_bundle,
                       None)
     expected_list = [
       { 'title': 'Description',
         'content': [
           { 'text': 'a test api' }
         ]
       },
@@ skipping 26 matching lines @@
           { 'link': 'https://tester.test.com/welcome.html',
             'text': 'Welcome!'
           }
         ]
       }
     ]
     self.assertEquals(model._GetIntroTableList(), expected_list)
 
     # Tests the same data with a scheduled availability.
     model = _JSCModel(self._api_models.GetModel('tester').Get(),
-                      _FakeScheduledAvailabilityFinder(),
-                      self._json_cache,
-                      _FakeTemplateCache(),
-                      self._features_bundle,
-                      None)
+        AvailabilityInfo(ChannelInfo('beta', '1453', 27), scheduled=28),
+        self._json_cache,
+        _FakeTemplateCache(),
+        self._features_bundle,
+        None)
     expected_list[1] = {
       'title': 'Availability',
       'content': [
         { 'partial': 'handlebar chrome/common/extensions/docs/' +
                      'templates/private/intro_tables/beta_message.html',
           'version': 27,
           'scheduled': 28
         }
       ]
     }
@@ skipping 14 matching lines @@
     events['types'][0]['functions'].append(add_rules)
     self.assertEqual(add_rules,
                      _GetEventByNameFromEvents(events)['addRules'])
 
     events['types'][0]['functions'].append(add_rules)
     # Duplicates are an error.
     self.assertRaises(AssertionError, _GetEventByNameFromEvents, events)
 
   def _FakeLoadAddRulesSchema(self):
     events = self._LoadJSON('add_rules_def_test.json')
-    return _GetEventByNameFromEvents(events)
+    return Future(value=_GetEventByNameFromEvents(events))
 
   def testAddRules(self):
     dict_ = _JSCModel(self._api_models.GetModel('add_rules_tester').Get(),
-                      _FakeAvailabilityFinder(),
+                      self._fake_availability,
                       self._json_cache,
                       _FakeTemplateCache(),
                       self._features_bundle,
-                      self._FakeLoadAddRulesSchema).ToDict()
+                      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()