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

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 from copy import deepcopy
   7 import json
   8 import os
   9 import sys
  10 import unittest
  11
  12 from api_data_source import (_JSCModel,
  13                              _FormatValue,
  14                              _GetEventByNameFromEvents)
  15 from branch_utility import ChannelInfo
  16 from collections import namedtuple
  17 from compiled_file_system import CompiledFileSystem
  18 from file_system import FileNotFoundError
  19 from future import Future
  20 from object_store_creator import ObjectStoreCreator
  21 from reference_resolver import ReferenceResolver
  22 from test_branch_utility import TestBranchUtility
  23 from test_data.canned_data import CANNED_TEST_FILE_SYSTEM_DATA
  24 from test_file_system import TestFileSystem
  25 import third_party.json_schema_compiler.json_parse as json_parse
  26
  27
  28 def _MakeLink(href, text):
  29   return '<a href="%s">%s</a>' % (href, text)
  30
  31
  32 def _GetType(dict_, name):
  33   for type_ in dict_['types']:
  34     if type_['name'] == name:
  35       return type_
  36
  37
  38 class _FakeAvailabilityFinder(object):
  39
  40   def GetApiAvailability(self, version):
  41     return ChannelInfo('stable', '396', 5)
  42
  43
  44 class _FakeSamplesDataSource(object):
  45
  46   def Create(self, request):
  47     return {}
  48
  49
  50 # Sad irony :(
  51 class _FakeAPIDataSource(object):
  52
  53   def __init__(self, json_data):
  54     self._json = json_data
  55
  56   def Create(self, *args, **kwargs):
  57     return self
  58
  59   def get(self, key, disable_refs=False):
  60     if key not in self._json:
  61       raise FileNotFoundError(key)
  62     return self._json[key]
  63
  64
  65 class _FakeAPIModels(object):
  66
  67   def __init__(self, names):
  68     self._names = names
  69
  70   def GetNames(self):
  71     return self._names
  72
  73
  74 class _FakeTemplateCache(object):
  75
  76   def GetFromFile(self, key):
  77     return Future(value='handlebar %s' % key)
  78
  79
  80 class APIDataSourceTest(unittest.TestCase):
  81
  82   def setUp(self):
  83     self._base_path = os.path.join(sys.path[0], 'test_data', 'test_json')
  84     self._compiled_fs_factory = CompiledFileSystem.Factory(
  85         ObjectStoreCreator.ForTest())
  86     self._json_cache = self._compiled_fs_factory.ForJson(
  87         TestFileSystem(CANNED_TEST_FILE_SYSTEM_DATA))
  88
  89   def _ReadLocalFile(self, filename):
  90     with open(os.path.join(self._base_path, filename), 'r') as f:
  91       return f.read()
  92
  93   def _CreateRefResolver(self, filename):
  94     test_data = self._LoadJSON(filename)
  95     return ReferenceResolver.Factory(_FakeAPIDataSource(test_data),
  96                                      _FakeAPIModels(test_data),
  97                                      ObjectStoreCreator.ForTest()).Create()
  98
  99   def _LoadJSON(self, filename):
 100     return json.loads(self._ReadLocalFile(filename))
 101
 102   def testCreateId(self):
 103     dict_ = _JSCModel(self._LoadJSON('test_file.json')[0],
 104                       self._CreateRefResolver('test_file_data_source.json'),
 105                       False,
 106                       _FakeAvailabilityFinder(),
 107                       TestBranchUtility.CreateWithCannedData(),
 108                       self._json_cache,
 109                       _FakeTemplateCache(),
 110                       None).ToDict()
 111     self.assertEquals('type-TypeA', dict_['types'][0]['id'])
 112     self.assertEquals('property-TypeA-b',
 113                       dict_['types'][0]['properties'][0]['id'])
 114     self.assertEquals('method-get', dict_['functions'][0]['id'])
 115     self.assertEquals('event-EventA', dict_['events'][0]['id'])
 116
 117   # TODO(kalman): re-enable this when we have a rebase option.
 118   def DISABLED_testToDict(self):
 119     filename = 'test_file.json'
 120     expected_json = self._LoadJSON('expected_' + filename)
 121     dict_ = _JSCModel(self._LoadJSON(filename)[0],
 122                       self._CreateRefResolver('test_file_data_source.json'),
 123                       False,
 124                       _FakeAvailabilityFinder(),
 125                       TestBranchUtility.CreateWithCannedData(),
 126                       self._json_cache,
 127                       _FakeTemplateCache(),
 128                       None).ToDict()
 129     self.assertEquals(expected_json, dict_)
 130
 131   def testFormatValue(self):
 132     self.assertEquals('1,234,567', _FormatValue(1234567))
 133     self.assertEquals('67', _FormatValue(67))
 134     self.assertEquals('234,567', _FormatValue(234567))
 135
 136   def testFormatDescription(self):
 137     dict_ = _JSCModel(self._LoadJSON('ref_test.json')[0],
 138                       self._CreateRefResolver('ref_test_data_source.json'),
 139                       False,
 140                       _FakeAvailabilityFinder(),
 141                       TestBranchUtility.CreateWithCannedData(),
 142                       self._json_cache,
 143                       _FakeTemplateCache(),
 144                       None).ToDict()
 145     self.assertEquals(_MakeLink('ref_test.html#type-type2', 'type2'),
 146                       _GetType(dict_, 'type1')['description'])
 147     self.assertEquals(
 148         'A %s, or %s' % (_MakeLink('ref_test.html#type-type3', 'type3'),
 149                          _MakeLink('ref_test.html#type-type2', 'type2')),
 150         _GetType(dict_, 'type2')['description'])
 151     self.assertEquals(
 152         '%s != %s' % (_MakeLink('other.html#type-type2', 'other.type2'),
 153                       _MakeLink('ref_test.html#type-type2', 'type2')),
 154         _GetType(dict_, 'type3')['description'])
 155
 156
 157   def testGetApiAvailability(self):
 158     model = _JSCModel(self._LoadJSON('test_file.json')[0],
 159                       self._CreateRefResolver('test_file_data_source.json'),
 160                       False,
 161                       _FakeAvailabilityFinder(),
 162                       TestBranchUtility.CreateWithCannedData(),
 163                       self._json_cache,
 164                       _FakeTemplateCache(),
 165                       None)
 166     # The model namespace is "tester". No predetermined availability is found,
 167     # so the _FakeAvailabilityFinder instance is used to find availability.
 168     self.assertEqual(ChannelInfo('stable', '396', 5),
 169                      model._GetApiAvailability())
 170
 171     # These APIs have predetermined availabilities in the
 172     # api_availabilities.json file within CANNED_DATA.
 173     model._namespace.name = 'trunk_api'
 174     self.assertEqual(ChannelInfo('trunk', 'trunk', 'trunk'),
 175                      model._GetApiAvailability())
 176
 177     model._namespace.name = 'dev_api'
 178     self.assertEqual(ChannelInfo('dev', '1500', 28),
 179                      model._GetApiAvailability())
 180
 181     model._namespace.name = 'beta_api'
 182     self.assertEqual(ChannelInfo('beta', '1453', 27),
 183                      model._GetApiAvailability())
 184
 185     model._namespace.name = 'stable_api'
 186     self.assertEqual(ChannelInfo('stable', '1132', 20),
 187                      model._GetApiAvailability())
 188
 189   def testGetIntroList(self):
 190     model = _JSCModel(self._LoadJSON('test_file.json')[0],
 191                       self._CreateRefResolver('test_file_data_source.json'),
 192                       False,
 193                       _FakeAvailabilityFinder(),
 194                       TestBranchUtility.CreateWithCannedData(),
 195                       self._json_cache,
 196                       _FakeTemplateCache(),
 197                       None)
 198     expected_list = [
 199       { 'title': 'Description',
 200         'content': [
 201           { 'text': 'a test api' }
 202         ]
 203       },
 204       { 'title': 'Availability',
 205         'content': [
 206           { 'partial': 'handlebar docs/templates/private/' +
 207                        'intro_tables/stable_message.html',
 208             'version': 5
 209           }
 210         ]
 211       },
 212       { 'title': 'Permissions',
 213         'content': [
 214           { 'class': 'override',
 215             'text': '"tester"'
 216           },
 217           { 'text': 'is an API for testing things.' }
 218         ]
 219       },
 220       { 'title': 'Manifest',
 221         'content': [
 222           { 'class': 'code',
 223             'text': '"tester": {...}'
 224           }
 225         ]
 226       },
 227       { 'title': 'Learn More',
 228         'content': [
 229           { 'link': 'https://tester.test.com/welcome.html',
 230             'text': 'Welcome!'
 231           }
 232         ]
 233       }
 234     ]
 235     self.assertEquals(model._GetIntroTableList(), expected_list)
 236
 237   def testGetEventByNameFromEvents(self):
 238     events = {}
 239     # Missing 'types' completely.
 240     self.assertRaises(AssertionError, _GetEventByNameFromEvents, events)
 241
 242     events['types'] = []
 243     # No type 'Event' defined.
 244     self.assertRaises(AssertionError, _GetEventByNameFromEvents, events)
 245
 246     events['types'].append({ 'name': 'Event',
 247                              'functions': []})
 248     add_rules = { "name": "addRules" }
 249     events['types'][0]['functions'].append(add_rules)
 250     self.assertEqual(add_rules,
 251                      _GetEventByNameFromEvents(events)['addRules'])
 252
 253     events['types'][0]['functions'].append(add_rules)
 254     # Duplicates are an error.
 255     self.assertRaises(AssertionError, _GetEventByNameFromEvents, events)
 256
 257   def _FakeLoadAddRulesSchema(self):
 258     events = self._LoadJSON('add_rules_def_test.json')
 259     return _GetEventByNameFromEvents(events)
 260
 261   def testAddRules(self):
 262     dict_ = _JSCModel(self._LoadJSON('add_rules_test.json')[0],
 263                       self._CreateRefResolver('test_file_data_source.json'),
 264                       False,
 265                       _FakeAvailabilityFinder(),
 266                       TestBranchUtility.CreateWithCannedData(),
 267                       self._json_cache,
 268                       _FakeTemplateCache(),
 269                       self._FakeLoadAddRulesSchema).ToDict()
 270     # Check that the first event has the addRulesFunction defined.
 271     self.assertEquals('tester', dict_['name'])
 272     self.assertEquals('rules', dict_['events'][0]['name'])
 273     self.assertEquals('notable_name_to_check_for',
 274                       dict_['events'][0]['byName']['addRules'][
 275                           'parameters'][0]['name'])
 276
 277     # Check that the second event has addListener defined.
 278     self.assertEquals('noRules', dict_['events'][1]['name'])
 279     self.assertEquals('tester', dict_['name'])
 280     self.assertEquals('noRules', dict_['events'][1]['name'])
 281     self.assertEquals('callback',
 282                       dict_['events'][0]['byName']['addListener'][
 283                           'parameters'][0]['name'])
 284
 285 if __name__ == '__main__':
 286   unittest.main()