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)