def testDataContextNode(self): # This happens to test the "value_of" tag as well. lang_model = language_model.LanguageModel('|') foo_def_dict = { 'className': 'Foo', 'type': 'string', } prototype = data_types.DataType(foo_def_dict, None, language_model=lang_model) dv = data_value.DataValue('four', prototype) source = '{% value_of data %}' template = django_template.Template(source) context = self._GetContext({'data': dv}) self.assertEquals('"four"', template.render(context)) context = self._GetContext({'data': 'foo'}) self.assertRaises(django_template.TemplateSyntaxError, template.render, context) bar_def_dict = { 'className': 'Foo', 'type': 'parrot', } prototype = data_types.DataType(bar_def_dict, None, language_model=lang_model) dv = data_value.DataValue('fred', prototype) context = self._GetContext({'data': dv}) self.assertRaises(django_template.TemplateSyntaxError, template.render, context)
def testConstructor(self): foo = self.language_model bar = language_model.LanguageModel() self.assertEqual(foo._SUPPORTED_TYPES.keys(), bar._SUPPORTED_TYPES.keys()) # Assure that if someone screws up overriding SUPPORTED_TYPES mappings # in subclasses we complain in the testing layer. foo._SUPPORTED_TYPES['bar'] = 'foo' self.assertNotEqual(foo._SUPPORTED_TYPES.keys(), bar._SUPPORTED_TYPES.keys())
def testSharedTypes(self): api = self.ApiFromDiscoveryDoc(self._TEST_SHARED_TYPES_DOC) api.VisitAll(lambda o: o.SetLanguageModel(language_model.LanguageModel())) # class defined by the API photos_feed_schema = api._schemas['PhotosFeed'] # type defined from a shared type repo photo_schema = api._schemas[ 'http://www.googleapis.com/types/v1/com.google/plus/v2/photo'] self.assertEquals('PhotosFeed', photos_feed_schema.values['wireName']) self.assertEquals('com.google.myservice', photos_feed_schema.module.name) self.assertEquals('Photo', photo_schema.values['wireName']) self.assertEquals('com.google.plus.pictures', photo_schema.module.name) self.assertEquals('com/google/plus/pictures', photo_schema.module.path)
def setUp(self): super(TemplateObjectsTest, self).setUp() self.language_model = language_model.LanguageModel(class_name_delimiter='|')
def testDataValue(self): foo_def_dict = { 'className': 'Foo', 'type': 'string', } prototype = data_types.DataType(foo_def_dict, None, language_model=self.language_model) dv = data_value.DataValue(3, prototype) # Basic Checks self.assertEqual(3, dv.value) self.assertEqual(prototype, dv.data_type) self.assertEqual({}, dv.metadata) self.assertEqual('Foo', dv.code_type) dv.metadata['foo'] = 'bar' self.assertEqual({'foo': 'bar'}, dv.metadata) dv.SetValue('four') self.assertEqual(dv.value, 'four') self.assertEqual(self.language_model, dv.GetLanguageModel()) other_language_model = language_model.LanguageModel( class_name_delimiter='+') dv.SetLanguageModel(other_language_model) self.assertEqual(other_language_model, dv.GetLanguageModel()) # Now that we've set a local language model... make sure the codepath # for setting the data_type's language model gets exercised. self.assertEqual('Foo', dv.code_type) # Check that the constructor doesn't freak if an odd object is passed in dv = data_value.DataValue(object, prototype) self.assertEqual(dv.value, object) # A standard case is the prototype being a Property object. It is not # uncommon that the Property's data_type is a SchemaReference. To verify # this case is handled correctly we must fake an API. bar_def_dict = { 'className': 'Foo', 'type': 'string', } class MockApi(object): def __init__(self): self.model_module = None def SetSchema(self, s): self.schema = s def SetSchemaRef(self, schema_ref): self.schema_ref = schema_ref # pylint: disable=unused-argument def ToClassName(self, name, element, element_type): return name # pylint: disable=unused-argument def SchemaByName(self, schema_name): return self.schema # pylint: disable=unused-argument def DataTypeFromJson(self, unused_def_dict, tentative_class_name, parent=None, wire_name=None): return self.schema_ref def NestedClassNameForProperty(self, name, owning_schema): return '%s%s' % (owning_schema.class_name, name) mock_api = MockApi() bar_schema = schema.Schema(mock_api, 'Bar', bar_def_dict) mock_api.SetSchema(bar_schema) schema_ref = data_types.SchemaReference('Bar', mock_api) mock_api.SetSchemaRef(schema_ref) prototype = schema.Property(mock_api, schema_ref, 'baz', foo_def_dict) dv = data_value.DataValue('3', prototype) # Assure all the unwrapping gymnastics in the DataValue constructor did # their job correctly. self.assertEqual(mock_api.schema, dv.data_type)
def setUp(self): super(DataValueTest, self).setUp() self.language_model = language_model.LanguageModel( class_name_delimiter='|')
def testVoidDataTypeDefault(self): api = template_objects.CodeObject({}, None) void = data_types.Void(api) api.SetLanguageModel(language_model.LanguageModel()) self.assertEquals('void', void.code_type)
def setUp(self): self.language_model = language_model.LanguageModel()