model_test.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265
  1. #!/usr/bin/env python3
  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. from json_schema import CachedLoad
  6. from idl_schema import Load
  7. from model import Platforms
  8. import model
  9. import unittest
  10. class ModelTest(unittest.TestCase):
  11. def setUp(self):
  12. self.model = model.Model()
  13. self.permissions_json = CachedLoad('test/permissions.json')
  14. self.model.AddNamespace(self.permissions_json[0],
  15. 'path/to/permissions.json')
  16. self.permissions = self.model.namespaces.get('permissions')
  17. self.windows_json = CachedLoad('test/windows.json')
  18. self.model.AddNamespace(self.windows_json[0],
  19. 'path/to/window.json')
  20. self.windows = self.model.namespaces.get('windows')
  21. self.tabs_json = CachedLoad('test/tabs.json')
  22. self.model.AddNamespace(self.tabs_json[0],
  23. 'path/to/tabs.json')
  24. self.tabs = self.model.namespaces.get('tabs')
  25. self.idl_chromeos = Load('test/idl_namespace_chromeos.idl')
  26. self.model.AddNamespace(self.idl_chromeos[0],
  27. 'path/to/idl_namespace_chromeos.idl')
  28. self.idl_namespace_chromeos = self.model.namespaces.get(
  29. 'idl_namespace_chromeos')
  30. self.idl_all_platforms = Load('test/idl_namespace_all_platforms.idl')
  31. self.model.AddNamespace(self.idl_all_platforms[0],
  32. 'path/to/idl_namespace_all_platforms.idl')
  33. self.idl_namespace_all_platforms = self.model.namespaces.get(
  34. 'idl_namespace_all_platforms')
  35. self.idl_non_specific_platforms = Load(
  36. 'test/idl_namespace_non_specific_platforms.idl')
  37. self.model.AddNamespace(self.idl_non_specific_platforms[0],
  38. 'path/to/idl_namespace_non_specific_platforms.idl')
  39. self.idl_namespace_non_specific_platforms = self.model.namespaces.get(
  40. 'idl_namespace_non_specific_platforms')
  41. self.returns_async_json = CachedLoad('test/returns_async.json')
  42. self.model.AddNamespace(self.returns_async_json[0],
  43. 'path/to/returns_async.json')
  44. self.returns_async = self.model.namespaces.get('returns_async')
  45. self.idl_returns_async_idl = Load('test/idl_returns_async.idl')
  46. self.model.AddNamespace(self.idl_returns_async_idl[0],
  47. 'path/to/idl_returns_async.idl')
  48. self.idl_returns_async = self.model.namespaces.get('idl_returns_async')
  49. self.nodoc_json = CachedLoad('test/namespace_nodoc.json')
  50. self.model.AddNamespace(self.nodoc_json[0],
  51. 'path/to/namespace_nodoc.json')
  52. self.nodoc = self.model.namespaces.get('nodoc')
  53. self.fakeapi_json = CachedLoad('test/namespace_fakeapi.json')
  54. self.model.AddNamespace(self.fakeapi_json[0],
  55. 'path/to/namespace_fakeapi.json')
  56. self.fakeapi = self.model.namespaces.get('fakeapi')
  57. self.function_platforms_idl = Load('test/function_platforms.idl')
  58. self.model.AddNamespace(self.function_platforms_idl[0],
  59. '/path/to/function_platforms.idl')
  60. self.function_platforms = self.model.namespaces.get('function_platforms')
  61. self.function_platform_win_linux_json = CachedLoad(
  62. 'test/function_platform_win_linux.json')
  63. self.model.AddNamespace(self.function_platform_win_linux_json[0],
  64. 'path/to/function_platform_win_linux.json')
  65. self.function_platform_win_linux = self.model.namespaces.get(
  66. 'function_platform_win_linux')
  67. def testNamespaces(self):
  68. self.assertEqual(12, len(self.model.namespaces))
  69. self.assertTrue(self.permissions)
  70. def testHasFunctions(self):
  71. self.assertEqual(["contains", "getAll", "remove", "request"],
  72. sorted(self.permissions.functions.keys()))
  73. def testHasTypes(self):
  74. self.assertEqual(['Tab'], list(self.tabs.types.keys()))
  75. self.assertEqual(['Permissions'], list(self.permissions.types.keys()))
  76. self.assertEqual(['Window'], list(self.windows.types.keys()))
  77. def testHasProperties(self):
  78. self.assertEqual(["active", "favIconUrl", "highlighted", "id",
  79. "incognito", "index", "pinned", "selected", "status", "title", "url",
  80. "windowId"],
  81. sorted(self.tabs.types['Tab'].properties.keys()))
  82. def testProperties(self):
  83. string_prop = self.tabs.types['Tab'].properties['status']
  84. self.assertEqual(model.PropertyType.STRING,
  85. string_prop.type_.property_type)
  86. integer_prop = self.tabs.types['Tab'].properties['id']
  87. self.assertEqual(model.PropertyType.INTEGER,
  88. integer_prop.type_.property_type)
  89. array_prop = self.windows.types['Window'].properties['tabs']
  90. self.assertEqual(model.PropertyType.ARRAY,
  91. array_prop.type_.property_type)
  92. self.assertEqual(model.PropertyType.REF,
  93. array_prop.type_.item_type.property_type)
  94. self.assertEqual('tabs.Tab', array_prop.type_.item_type.ref_type)
  95. object_prop = self.tabs.functions['query'].params[0]
  96. self.assertEqual(model.PropertyType.OBJECT,
  97. object_prop.type_.property_type)
  98. self.assertEqual(
  99. ["active", "highlighted", "pinned", "status", "title", "url",
  100. "windowId", "windowType"],
  101. sorted(object_prop.type_.properties.keys()))
  102. def testChoices(self):
  103. self.assertEqual(model.PropertyType.CHOICES,
  104. self.tabs.functions['move'].params[0].type_.property_type)
  105. def testPropertyNotImplemented(self):
  106. (self.permissions_json[0]['types'][0]
  107. ['properties']['permissions']['type']) = 'something'
  108. self.assertRaises(model.ParseException, self.model.AddNamespace,
  109. self.permissions_json[0], 'path/to/something.json')
  110. def testDefaultSpecifiedRedundantly(self):
  111. test_json = CachedLoad('test/redundant_default_attribute.json')
  112. self.assertRaisesRegex(
  113. model.ParseException,
  114. 'Model parse exception at:\nredundantDefaultAttribute\noptionalFalse\n'
  115. ' in path/to/redundant_default_attribute.json\n'
  116. 'The attribute "optional" is specified as "False", but this is the '
  117. 'default value if the attribute is not included\. It should be '
  118. 'removed\.',
  119. self.model.AddNamespace,
  120. test_json[0],
  121. 'path/to/redundant_default_attribute.json')
  122. def testReturnsAsyncMissingParametersKey(self):
  123. test_json = CachedLoad('test/returns_async_missing_parameters_key.json')
  124. self.assertRaisesRegex(
  125. ValueError,
  126. 'parameters key not specified on returns_async: '
  127. 'returnsAsyncMissingParametersKey.asyncNoParametersKey in '
  128. 'path/to/returns_async_missing_parameters_key.json',
  129. self.model.AddNamespace,
  130. test_json[0],
  131. 'path/to/returns_async_missing_parameters_key.json')
  132. def testDescription(self):
  133. self.assertFalse(
  134. self.permissions.functions['contains'].params[0].description)
  135. self.assertEqual(
  136. 'True if the extension has the specified permissions.', self.
  137. permissions.functions['contains'].returns_async.params[0].description)
  138. def testAsyncPromise(self):
  139. supportsPromises = self.returns_async.functions['supportsPromises']
  140. self.assertTrue(supportsPromises.returns_async.can_return_promise)
  141. doesNotSupportPromises = self.returns_async.functions[
  142. 'doesNotSupportPromises']
  143. self.assertFalse(doesNotSupportPromises.returns_async.can_return_promise)
  144. supportsPromisesIdl = self.idl_returns_async.functions['supportsPromises']
  145. self.assertTrue(supportsPromisesIdl.returns_async.can_return_promise)
  146. doesNotSupportPromisesIdl = self.idl_returns_async.functions[
  147. 'doesNotSupportPromises']
  148. self.assertFalse(doesNotSupportPromisesIdl.returns_async.can_return_promise)
  149. def testPropertyUnixName(self):
  150. param = self.tabs.functions['move'].params[0]
  151. self.assertEqual('tab_ids', param.unix_name)
  152. def testUnixName(self):
  153. expectations = {
  154. 'foo': 'foo',
  155. 'fooBar': 'foo_bar',
  156. 'fooBarBaz': 'foo_bar_baz',
  157. 'fooBARBaz': 'foo_bar_baz',
  158. 'fooBAR': 'foo_bar',
  159. 'FOO': 'foo',
  160. 'FOOBar': 'foo_bar',
  161. 'foo.bar': 'foo_bar',
  162. 'foo.BAR': 'foo_bar',
  163. 'foo.barBAZ': 'foo_bar_baz',
  164. 'foo_Bar_Baz_box': 'foo_bar_baz_box',
  165. }
  166. for name in expectations:
  167. self.assertEqual(expectations[name], model.UnixName(name))
  168. def testCamelName(self):
  169. expectations = {
  170. 'foo': 'foo',
  171. 'fooBar': 'fooBar',
  172. 'foo_bar_baz': 'fooBarBaz',
  173. 'FOO_BAR': 'FOOBar',
  174. 'FOO_bar': 'FOOBar',
  175. '_bar': 'Bar',
  176. '_bar_baz': 'BarBaz',
  177. 'bar_': 'bar',
  178. 'bar_baz_': 'barBaz',
  179. }
  180. for testcase, expected in expectations.items():
  181. self.assertEqual(expected, model.CamelName(testcase))
  182. def testPlatforms(self):
  183. self.assertEqual([Platforms.CHROMEOS],
  184. self.idl_namespace_chromeos.platforms)
  185. self.assertEqual(
  186. [Platforms.CHROMEOS, Platforms.FUCHSIA, Platforms.LINUX, Platforms.MAC,
  187. Platforms.WIN],
  188. self.idl_namespace_all_platforms.platforms)
  189. self.assertEqual(None,
  190. self.idl_namespace_non_specific_platforms.platforms)
  191. def testInvalidNamespacePlatform(self):
  192. invalid_namespace_platform = Load('test/invalid_platform_namespace.idl')
  193. with self.assertRaises(ValueError) as context:
  194. self.model.AddNamespace(invalid_namespace_platform[0],
  195. 'path/to/something.json')
  196. self.assertIn('Invalid platform specified: invalid', str(context.exception))
  197. def testInvalidFunctionPlatform(self):
  198. invalid_function_platform = Load('test/invalid_function_platform.idl')
  199. with self.assertRaises(ValueError) as context:
  200. self.model.AddNamespace(invalid_function_platform[0],
  201. 'path/to/something.json')
  202. self.assertIn('Invalid platform specified: windows', str(context.exception))
  203. def testPlatformsOnFunctionsIDL(self):
  204. function_win_linux = self.function_platforms.functions['function_win_linux']
  205. self.assertEqual([Platforms.WIN, Platforms.LINUX],
  206. function_win_linux.platforms)
  207. function_all = self.function_platforms.functions['function_all']
  208. self.assertIsNone(function_all.platforms)
  209. function_cros = self.function_platforms.functions['function_cros']
  210. self.assertEqual([Platforms.CHROMEOS], function_cros.platforms)
  211. function_fuchsia = self.function_platforms.functions['function_fuchsia']
  212. self.assertEqual([Platforms.FUCHSIA], function_fuchsia.platforms)
  213. def testPlatformsOnFunctionsJSON(self):
  214. test_function = self.function_platform_win_linux.functions['test']
  215. self.assertEqual([Platforms.WIN, Platforms.LINUX], test_function.platforms)
  216. def testHasNoDoc(self):
  217. fakeapi_NoDocType = self.fakeapi.types['NoDocType']
  218. self.assertTrue(fakeapi_NoDocType.nodoc)
  219. fakeapi_FakeType = self.fakeapi.types['FakeType']
  220. selected_property = fakeapi_FakeType.properties['nodocProperty']
  221. self.assertTrue(selected_property.nodoc)
  222. nodocMethod_method = self.fakeapi.functions['nodocMethod']
  223. self.assertTrue(nodocMethod_method.nodoc)
  224. onFooNoDoc_event = self.fakeapi.events['onFooNoDoc']
  225. self.assertTrue(onFooNoDoc_event.nodoc)
  226. onFoo_event = self.fakeapi.events['onFoo']
  227. self.assertFalse(onFoo_event.nodoc)
  228. self.assertTrue(self.nodoc.nodoc, 'Namespace should also be marked nodoc')
  229. nodoc_ValidType = self.nodoc.types['ValidType']
  230. self.assertFalse(nodoc_ValidType.nodoc)
  231. if __name__ == '__main__':
  232. unittest.main()