def testExponentialBackoffDefault(self):
# Make sure exponentialBackoffDefault defaults to False.
discovery_doc = json.loads(
"""
{
"name": "fake",
"version": "v1",
"schemas": {},
"resources": {}
}
""")
api = Api(discovery_doc)
# Make sure exponentialBackoffDefault gets set to True.
self.assertFalse(api.values['exponentialBackoffDefault'])
discovery_doc2 = json.loads(
"""
{
"name": "fake",
"version": "v1",
"schemas": {},
"resources": {},
"exponentialBackoffDefault": true
}
""")
api2 = Api(discovery_doc2)
self.assertTrue(api2.values['exponentialBackoffDefault'])
def MakeApiWithSchemas(schemas):
discovery_doc = {
'name': 'fake',
'version': 'v1',
'resources': {},
'schemas': schemas
}
api = Api(discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(FakeLanguageModel()))
return api
def testApiHasTitle(self):
api_def = {'name': 'fake',
'version': 'v1',
'schemas': {},
'resources': {}}
api = Api(api_def)
self.assertEquals('fake', api['title'])
def testUnknownHttpMethod(self):
"""Make sure we get an exception on unknown HTTP types."""
api = Api({'name': 'dummy', 'version': 'v1', 'resources': {}})
unused_resource = Resource(api, 'temp', {'methods': {}})
self.assertRaises(
ApiException, Method, api, 'bad', {
'rpcMethod': 'rpc',
'httpMethod': 'Not GET/POST/PUT/DELETE',
'parameters': {}
})
def testArrayOfArray(self):
class FakeLanguageModel(language_model.LanguageModel):
def GetCodeTypeFromDictionary(self, def_dict):
return def_dict.get('type')
def CodeTypeForArrayOf(self, s):
return 'Array[%s]' % s
discovery_doc = {
'name': 'fake',
'version': 'v1',
'schemas': {
'AdsenseReportsGenerateResponse': {
'id': 'AdsenseReportsGenerateResponse',
'type': 'object',
'properties': {
'basic': {
'type': 'string'
},
'simple_array': {
'type': 'array',
'items': {'type': 'string'}
},
'array_of_arrays': {
'type': 'array',
'items': {'type': 'array', 'items': {'type': 'string'}}
}
}
}
},
'resources': {}
}
api = Api(discovery_doc)
self.language_model = FakeLanguageModel()
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
response_schema = api._schemas.get('AdsenseReportsGenerateResponse')
self.assertTrue(response_schema)
prop = [prop for prop in response_schema.values['properties']
if prop.values['wireName'] == 'array_of_arrays']
self.assertTrue(len(prop) == 1)
prop = prop[0]
self.assertEquals('Array[Array[string]]', prop.codeType)
def ApiFromDiscoveryDoc(self, path):
"""Load a discovery doc from a file and creates a library Api.
Args:
path: (str) The path to the document.
Returns:
An Api for that document.
"""
f = open(os.path.join(os.path.dirname(__file__), 'testdata', path))
discovery_doc = json.loads(f.read())
f.close()
return Api(discovery_doc)
def testMakeDefaultSchemaNameFromTheDictTag(self):
"""Use the outer tag as id for schemas which have no id in their dict."""
discovery_doc = json.loads("""
{
"name": "fake",
"version": "v1",
"schemas": {
"should_use_id": {
"id": "named",
"type": "object",
"properties": { "dummy": { "type": "string" } }
},
"unnamed": {
"type": "object",
"properties": { "dummy": { "type": "string" } }
}
},
"resources": {}
}
""")
gen = Api(discovery_doc)
self.assertTrue('named' in gen._schemas)
self.assertTrue('unnamed' in gen._schemas)
def testUndefinedSchema(self):
# This should generated an empty "Bar" class.
discovery_doc = {
'name': 'fake',
'version': 'v1',
'schemas': {
'foo': {
'id': 'foo',
'type': 'object',
'properties': {'basic': {'$ref': 'bar'}}
}
},
'resources': {}
}
gen = Api(discovery_doc)
# We expect foo to be in the list because the id is 'foo'
self.assertTrue('foo' in gen._schemas.keys())
# We expect 'Foo' to be in the list because that is the class name we would
# create for foo
self.assertTrue('Foo' in gen._schemas.keys())
# We do not expect Bar to be in the list because we only have a ref to it
# but no definition.
self.assertFalse('Bar' in gen._schemas.keys())
def testModuleOwnerDomainAndPackagePath(self):
self.discovery_doc['ownerDomain'] = 'toasty.com'
self.discovery_doc['packagePath'] = 'foo/BAR'
api = Api(self.discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
self.assertEquals('com/toasty/foo/BAR/fake', api.values['module'].path)
def testModulePackagePath(self):
self.discovery_doc['packagePath'] = 'foo/BAR'
api = Api(self.discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
self.assertEquals('com/google/foo/BAR/fake', api.values['module'].path)
def testModuleOwnerDomain(self):
self.discovery_doc['ownerDomain'] = 'foo.bar'
api = Api(self.discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
self.assertEquals('bar/foo/fake', api.values['module'].path)
def LoadApi(**kwargs):
d = {'name': 'fake', 'version': 'v1'}
d.update(kwargs)
return Api(d)
def testCanonicalName(self):
d = {'name': 'fake', 'version': 'v1', 'canonicalName': 'My API'}
api = Api(d)
self.assertEquals('fake', api.values['name'])
self.assertEquals('MyAPI', api._class_name)
def LoadApi(discovery_dict):
d = {'name': 'fake', 'version': 'v1'}
d.update(discovery_dict)
api = Api(d)
return api
def main(unused_argv):
if not FLAGS.discovery:
raise app.UsageError('You must specify --discovery')
if not (FLAGS.output_dir or FLAGS.output_file):
raise app.UsageError(
'You must specify one of --output_dir or --output_file')
if not FLAGS.templates:
raise app.UsageError('You must specify --templates')
f = open(FLAGS.discovery)
discovery_doc = json.loads(f.read())
f.close()
options = {
# Include other files needed to compile (e.g. base jar files)
'include_dependencies': False,
# Include the timestamp in the generated library
'include_timestamp': FLAGS.include_timestamp,
# Put API version in the package
'version_package': FLAGS.version_package,
}
if FLAGS.output_type == 'full':
options['include_dependencies'] = True
# try to determine what generator to use from the language variant.
language_variants = Targets().VariationsForLanguage(FLAGS.language)
if language_variants:
features = language_variants.GetFeatures(FLAGS.language_variant)
template_dir = features.template_dir
generator_name = features.get('generator', FLAGS.language)
else:
# Not described by targets.json. The template dir should just be down
# in the language specific folder
template_dir = os.path.join(os.path.dirname(__file__), 'languages',
FLAGS.language)
features = None
generator_name = FLAGS.language
# Instantiate the right code generator
lang_model = None
try:
if FLAGS.language == 'any':
api = Api(discovery_doc)
# TODO(user): A default language model should be built in to the
# templates
lang_model = language_model.DocumentingLanguageModel()
else:
generator_class = generator_lookup.GetGeneratorByLanguage(
generator_name)
generator_instance = generator_class(discovery_doc)
api = generator_instance.api
lang_model = generator_instance.language_model
except ValueError:
raise app.UsageError('Unsupported language option: %s' %
FLAGS.language)
api.VisitAll(lambda o: o.SetLanguageModel(lang_model))
gen = TemplateExpander(api, options=options)
if features:
gen.SetFeatures(features)
template_dir = os.path.join(template_dir, FLAGS.templates)
if not os.path.isdir(template_dir):
raise app.UsageError('Can not find template tree at: %s' %
template_dir)
gen.SetTemplateDir(template_dir)
# Get an output writer
package_writer = package_writer_foundry.GetPackageWriter(
output_dir=FLAGS.output_dir,
output_file=FLAGS.output_file,
output_format=FLAGS.output_format)
# do it
gen.GeneratePackage(package_writer)
package_writer.DoneWritingArchive()
return 0
def testWrappedContainer(self):
discovery_doc = {
'name': 'fake',
'version': 'v1',
}
api = Api(discovery_doc)
wrapped_container_def = {
'id': 'SeriesList',
'type': 'object',
'properties': {
'items': {
'type': 'array',
'items': {
'$ref': 'Snorg'
}
},
}
}
schema = Schema.Create(api, 'foo', wrapped_container_def, 'foo', None)
self.assertEquals(1, len(schema.properties))
self.assertIsNotNone(schema.isContainerWrapper)
container_property = schema.containerProperty
self.assertIsNotNone(container_property)
array_of = container_property.data_type.GetTemplateValue('arrayOf')
self.assertIsNotNone(array_of)
self.assertEquals('Snorg', array_of.values['wireName'])
# Add a kind
wrapped_container_def['properties'].update(
{'kind': {
'type': 'string'
}})
schema = Schema.Create(api, 'foo', wrapped_container_def, 'foo', None)
self.assertEquals(2, len(schema.properties))
self.assertTrue(schema.isContainerWrapper)
# Add an etag
wrapped_container_def['properties'].update(
{'etag': {
'type': 'string'
}})
schema = Schema.Create(api, 'foo', wrapped_container_def, 'foo', None)
self.assertEquals(3, len(schema.properties))
self.assertTrue(schema.isContainerWrapper)
# Add a field which disqualifies
wrapped_container_def['properties'].update({'foo': {'type': 'string'}})
schema = Schema.Create(api, 'foo', wrapped_container_def, 'foo', None)
self.assertEquals(4, len(schema.properties))
self.assertFalse(schema.isContainerWrapper)
# Make the main property not a container
not_wrapped_container_def = {
'id': 'SeriesList',
'type': 'object',
'properties': {
'items': {
'type': 'string'
},
'kind': {
'type': 'string'
}
}
}
schema = Schema.Create(api, 'foo', not_wrapped_container_def, 'foo',
None)
self.assertEquals(2, len(schema.properties))
self.assertFalse(schema.isContainerWrapper)
