def testGenerateErrorMessages(self):
schema = idl_schema.Load('test/idl_generate_error_messages.idl')[0]
self.assertEquals('idl_generate_error_messages', schema['namespace'])
self.assertTrue(schema['compiler_options'].get(
'generate_error_messages', False))
schema = idl_schema.Load('test/idl_basics.idl')[0]
self.assertEquals('idl_basics', schema['namespace'])
self.assertFalse(schema['compiler_options'].get(
'generate_error_messages', False))
def testNonSpecificPlatformsNamespace(self):
schema = idl_schema.Load(
'test/idl_namespace_non_specific_platforms.idl')[0]
self.assertEquals('idl_namespace_non_specific_platforms',
schema['namespace'])
expected = None
self.assertEquals(expected, schema['platforms'])
def testUnionsWithCallbacks(self):
schema = idl_schema.Load('test/idl_function_types.idl')[0]
blah_params = getParams(schema, 'blah')
expected = [{
'type': 'function', 'name': 'callback', 'parameters': [{
'name': 'x',
'choices': [
{'type': 'integer'},
{'type': 'string'}
]}
]
}]
self.assertEquals(expected, blah_params)
badabish_params = getParams(schema, 'badabish')
expected = [{
'type': 'function', 'name': 'callback', 'parameters': [{
'name': 'x', 'optional': True, 'choices': [
{'type': 'integer'},
{'type': 'string'}
]
}]
}]
self.assertEquals(expected, badabish_params)
def testReservedWords(self):
schema = idl_schema.Load('test/idl_reserved_words.idl')[0]
foo_type = getType(schema, 'Foo')
self.assertEquals([{
'name': 'float'
}, {
'name': 'DOMString'
}], foo_type['enum'])
enum_type = getType(schema, 'enum')
self.assertEquals([{
'name': 'callback'
}, {
'name': 'namespace'
}], enum_type['enum'])
dictionary = getType(schema, 'dictionary')
self.assertEquals('integer', dictionary['properties']['long']['type'])
mytype = getType(schema, 'MyType')
self.assertEquals('string', mytype['properties']['interface']['type'])
params = getParams(schema, 'static')
self.assertEquals('Foo', params[0]['$ref'])
self.assertEquals('enum', params[1]['$ref'])
def testProperties(self):
schema = idl_schema.Load('test/idl_properties.idl')[0]
self.assertEquals(
OrderedDict([
('first',
OrderedDict([
('description', 'Integer property.'),
('jsexterns', None),
('type', 'integer'),
('value', 42),
])),
('second',
OrderedDict([
('description', 'Double property.'),
('jsexterns', None),
('type', 'number'),
('value', 42.1),
])),
('third',
OrderedDict([
('description', 'String property.'),
('jsexterns', None),
('type', 'string'),
('value', 'hello world'),
])),
('fourth',
OrderedDict([
('description', 'Unvalued property.'),
('jsexterns', None),
('type', 'integer'),
])),
]), schema.get('properties'))
def setUp(self):
self.models = defaultdict(model.Model)
self.forbidden_json = CachedLoad('test/forbidden.json')
self.forbidden = self.models['forbidden'].AddNamespace(
self.forbidden_json[0], 'path/to/forbidden.json')
self.permissions_json = CachedLoad('test/permissions.json')
self.permissions = self.models['permissions'].AddNamespace(
self.permissions_json[0], 'path/to/permissions.json')
self.windows_json = CachedLoad('test/windows.json')
self.windows = self.models['windows'].AddNamespace(
self.windows_json[0], 'path/to/window.json')
self.tabs_json = CachedLoad('test/tabs.json')
self.tabs = self.models['tabs'].AddNamespace(self.tabs_json[0],
'path/to/tabs.json')
self.browser_action_json = CachedLoad('test/browser_action.json')
self.browser_action = self.models['browser_action'].AddNamespace(
self.browser_action_json[0], 'path/to/browser_action.json')
self.font_settings_json = CachedLoad('test/font_settings.json')
self.font_settings = self.models['font_settings'].AddNamespace(
self.font_settings_json[0], 'path/to/font_settings.json')
self.dependency_tester_json = CachedLoad('test/dependency_tester.json')
self.dependency_tester = self.models['dependency_tester'].AddNamespace(
self.dependency_tester_json[0], 'path/to/dependency_tester.json')
self.content_settings_json = CachedLoad('test/content_settings.json')
self.content_settings = self.models['content_settings'].AddNamespace(
self.content_settings_json[0], 'path/to/content_settings.json')
self.objects_movable_idl = idl_schema.Load('test/objects_movable.idl')
self.objects_movable = self.models['objects_movable'].AddNamespace(
self.objects_movable_idl[0],
'path/to/objects_movable.idl',
include_compiler_options=True)
def testObjectTypesWithOptionalFields(self):
schema = idl_schema.Load('test/idl_object_types.idl')[0]
baz_type = getType(schema, 'BazType')
self.assertEquals(True, baz_type['properties']['x']['optional'])
self.assertEquals('integer', baz_type['properties']['x']['type'])
self.assertEquals(True, baz_type['properties']['foo']['optional'])
self.assertEquals('FooType', baz_type['properties']['foo']['$ref'])
def parse_idl_file(path):
""" Load the specified file and parse it as IDL.
Args:
path: Path to a file containing JSON-encoded data.
"""
api_def = idl_schema.Load(path)
return api_def
def testSpecificImplementNamespace(self):
schema = idl_schema.Load(
'test/idl_namespace_specific_implement.idl')[0]
self.assertEquals('idl_namespace_specific_implement',
schema['namespace'])
expected = 'idl_namespace_specific_implement.idl'
self.assertEquals(expected,
schema['compiler_options']['implemented_in'])
def testSpecificImplementOnChromeOSNamespace(self):
schema = idl_schema.Load(
'test/idl_namespace_specific_implement_chromeos.idl')[0]
self.assertEquals('idl_namespace_specific_implement_chromeos',
schema['namespace'])
expected_implemented_path = 'idl_namespace_specific_implement_chromeos.idl'
expected_platform = ['chromeos']
self.assertEquals(expected_implemented_path,
schema['compiler_options']['implemented_in'])
self.assertEquals(expected_platform, schema['platforms'])
def testObjectTypesInFunctions(self):
schema = idl_schema.Load('test/idl_object_types.idl')[0]
params = getParams(schema, 'objectFunction1')
self.assertEquals('object', params[0]['type'])
self.assertEquals('any', params[0]['additionalProperties']['type'])
self.assertEquals('ImageData', params[0]['isInstanceOf'])
params = getParams(schema, 'objectFunction2')
self.assertEquals('any', params[0]['type'])
def load_schema(schema):
schema_filename, schema_extension = os.path.splitext(schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema)
else:
sys.exit("Did not recognize file extension %s for schema %s" %
(schema_extension, schema))
return api_defs
def testUnionsWithFunctions(self):
schema = idl_schema.Load('test/idl_function_types.idl')[0]
union_params = getParams(schema, 'union_params')
expected = [{
'name': 'x',
'choices': [
{'type': 'integer'},
{'type': 'string'}
]
}]
self.assertEquals(expected, union_params)
def testFunctionWithPromise(self):
schema = idl_schema.Load('test/idl_function_types.idl')[0]
promise_function = getFunction(schema, 'promise_supporting')
expected = OrderedDict([
('parameters', []),
('returns_async', {
'name': 'callback',
'parameters': [{'name': 'x', 'type': 'integer'}]
}),
('name', 'promise_supporting'),
('type', 'function')
])
self.assertEquals(expected, promise_function)
def testObjectTypesWithUnions(self):
schema = idl_schema.Load('test/idl_object_types.idl')[0]
union_type = getType(schema, 'UnionType')
expected = {
'type': 'object',
'id': 'UnionType',
'properties': {
'x': {
'name': 'x',
'optional': True,
'choices': [
{
'type': 'integer'
},
{
'$ref': 'FooType'
},
]
},
'y': {
'name':
'y',
'choices': [{
'type': 'string'
}, {
'type': 'object',
'additionalProperties': {
'type': 'any'
}
}]
},
'z': {
'name':
'z',
'choices': [{
'type': 'object',
'isInstanceOf': 'ImageData',
'additionalProperties': {
'type': 'any'
}
}, {
'type': 'integer'
}]
}
},
}
self.assertEquals(expected, union_type)
def testArrayOfCallbacks(self):
schema = idl_schema.Load('test/idl_function_types.idl')[0]
expected = [{
'type': 'array',
'name': 'callbacks',
'items': {
'type': 'function',
'name': 'MyCallback',
'parameters': [{
'type': 'integer',
'name': 'x'
}]
}
}]
self.assertEquals(expected, getParams(schema, 'whatever'))
def LoadSchema(self, schema):
'''Load a schema definition. The schema parameter must be a file name
with the full path relative to the root.'''
schema_filename, schema_extension = os.path.splitext(schema)
schema_path = os.path.join(self._root, schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema_path)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema_path)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
return api_defs
def LoadSchema(self, schema):
schema_filename, schema_extension = os.path.splitext(schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
if len(api_defs) != 1:
sys.exit('File %s has multiple schemas. Files are only allowed to contain'
'a single schema.' % schema)
return api_defs
def LoadSchema(self, schema):
'''Load a schema definition. The schema parameter must be a file name
with the full path relative to the root.'''
_, schema_extension = os.path.splitext(schema)
schema_path = os.path.join(self._root, schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema_path)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema_path)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
# TODO(devlin): This returns a list. Does it need to? Is it ever > 1?
return api_defs
def testSerializableFunctionType(self):
schema = idl_schema.Load('test/idl_object_types.idl')[0]
object_type = getType(schema, 'SerializableFunctionObject')
expected = {
'type': 'object',
'id': 'SerializableFunctionObject',
'properties': {
'func': {
'name': 'func',
'serializableFunction': True,
'type': 'function',
'parameters': []
}
}
}
self.assertEquals(expected, object_type)
def LoadSchema(self, schema):
'''Load a schema definition. The schema parameter must be a file name
without any path component - the file is loaded from the path defined by
the real_path argument passed to the constructor.'''
schema_filename, schema_extension = os.path.splitext(schema)
schema_path = os.path.join(self._real_path, schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema_path)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema_path)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
return api_defs
def testObjectTypes(self):
schema = idl_schema.Load('test/idl_object_types.idl')[0]
foo_type = getType(schema, 'FooType')
self.assertEquals('object', foo_type['type'])
self.assertEquals('integer', foo_type['properties']['x']['type'])
self.assertEquals('object', foo_type['properties']['y']['type'])
self.assertEquals(
'any', foo_type['properties']['y']['additionalProperties']['type'])
self.assertEquals('object', foo_type['properties']['z']['type'])
self.assertEquals(
'any', foo_type['properties']['z']['additionalProperties']['type'])
self.assertEquals('Window',
foo_type['properties']['z']['isInstanceOf'])
bar_type = getType(schema, 'BarType')
self.assertEquals('object', bar_type['type'])
self.assertEquals('any', bar_type['properties']['x']['type'])
def testUnionsWithModifiers(self):
schema = idl_schema.Load('test/idl_object_types.idl')[0]
union_type = getType(schema, 'ModifiedUnionType')
expected = {
'type': 'object',
'id': 'ModifiedUnionType',
'properties': {
'x': {
'name': 'x',
'nodoc': True,
'choices': [
{'type': 'integer'},
{'type': 'string'}
]
}
}
}
self.assertEquals(expected, union_type)
def testAllPlatformsNamespace(self):
schema = idl_schema.Load('test/idl_namespace_all_platforms.idl')[0]
self.assertEquals('idl_namespace_all_platforms', schema['namespace'])
expected = ['chromeos', 'chromeos_touch', 'linux', 'mac', 'win']
self.assertEquals(expected, schema['platforms'])
def testNoManifestKeys(self):
schema = idl_schema.Load('test/idl_properties.idl')[0]
self.assertIsNone(schema.get('manifest_keys'))
def parse_idl_file(path):
""" Load the specified file and parse it as IDL.
Args:
path: Path to a file containing JSON-encoded data.
"""
api_def = idl_schema.Load(path)
for namespace_def in api_def:
namespace_dot = namespace_def['namespace'] + '.'
types = dict((type_['id'], type_)
for type_ in namespace_def.get('types', []) if type_)
def SubstituteInlineDoc(prop):
prop_ref_type = prop.get('$ref', '')
type_obj = types.get(namespace_dot + prop_ref_type,
types.get(prop_ref_type, {}))
if not type_obj:
return
if 'properties' in type_obj:
del prop['$ref']
prop['properties'] = dict(type_obj['properties'])
prop['type'] = 'object'
for sub_prop in prop['properties'].values():
if isinstance(sub_prop, dict):
if 'nodoc' in sub_prop:
del sub_prop['nodoc']
if 'name' in sub_prop:
del sub_prop['name']
elif 'enum' in type_obj and 'type' in type_obj:
del prop['$ref']
prop['type'] = type_obj['type']
prop['enum'] = type_obj['enum']
def FixReferences(prop):
# Strip namespace_dot from $ref names.
if prop.get('$ref', '').startswith(namespace_dot):
prop['$ref'] = prop['$ref'][len(namespace_dot):]
if (prop.get('type', '') == 'array' and prop.get('items', {}).get(
'$ref', '').startswith(namespace_dot)):
prop['items']['$ref'] = prop['items']['$ref'][len(namespace_dot
):]
if prop.get('inline_doc', False):
del prop['inline_doc']
SubstituteInlineDoc(prop)
if 'items' in prop:
SubstituteInlineDoc(prop['items'])
for type_ in namespace_def.get('types', []):
if type_.get('id', '').startswith(namespace_dot):
type_['id'] = type_['id'][len(namespace_dot):]
for prop in type_.get('properties', {}).values():
FixReferences(prop)
for func in namespace_def.get('functions', []):
for param in func.get('parameters', []):
FixReferences(param)
for cb_param in param.get('parameters', []):
FixReferences(cb_param)
for event in namespace_def.get('events', []):
for param in event.get('parameters', []):
FixReferences(param)
return api_def
def testChromeOSPlatformsNamespace(self):
schema = idl_schema.Load('test/idl_namespace_chromeos.idl')[0]
self.assertEquals('idl_namespace_chromeos', schema['namespace'])
expected = ['chromeos']
self.assertEquals(expected, schema['platforms'])
def setUp(self):
loaded = idl_schema.Load('test/idl_basics.idl')
self.assertEquals(1, len(loaded))
self.assertEquals('idl_basics', loaded[0]['namespace'])
self.idl_basics = loaded[0]
self.maxDiff = None
