def test_build_message_invalid_implementation_field(self):
""" Test `build_message` with an invalid explicit implementation field """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int, {'field': 'NoSuchField'}
with self.assertRaises(ValueError):
protorpc.build_message(SimpleModel)
def test_build_message_bogus_explicit_field(self):
""" Test `build_message` with a bogus field value """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
color = basestring, {'field': 5.5}
with self.assertRaises(TypeError):
protorpc.build_message(SimpleModel)
def test_build_message_required(self):
""" Test `build_message` with a required property """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int, {'required': True}
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi')
message = message_class(string='hi')
assert _model.string == message.string
assert _model.integer == message.integer
with self.assertRaises(exceptions.PropertyRequired):
_model.put()
with self.assertRaises(messages.ValidationError):
message.check_initialized()
def test_build_message_hook(self):
""" Test `build_message` with a target object hook """
class SomeProperty(model.Property):
""" Simple property with __message__ hook """
_basetype = basestring
@classmethod
def __message__(cls, *args, **kwargs):
""" Return an IntegerField implementation... """
return messages.IntegerField(*args, **kwargs)
class SimpleModel(model.Model):
""" Simple model message """
string = SomeProperty
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='5') # it's a basestring...
message = message_class(string=5) # jk its an int! lol
assert int(_model.string) == message.string
def test_build_message_key(self):
""" Test `build_message` with a `Key` property """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int
ref = model.Key
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert hasattr(message_class, 'ref')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi', integer=5, ref=model.Key('hi', 1))
message = message_class(string='hi', integer=5, ref=model.Key('hi', 1).to_message())
_msg_from_obj = _model.to_message()
assert _model.string == message.string
assert _model.integer == message.integer
assert _model.ref.urlsafe() == message.ref.encoded
assert _msg_from_obj.ref.encoded == _model.ref.urlsafe()
assert _msg_from_obj.ref.id == 1
def test_build_message_variant_vanilla_model(self):
""" Test `build_message` with a variant property (by vanilla `Model`) """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int
data = model.Model
some_model = SimpleModel(string='hithere')
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert hasattr(message_class, 'data')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi', integer=5, data=some_model)
message = message_class(string='hi', integer=5, data=some_model.to_dict())
assert _model.string == message.string
assert _model.integer == message.integer
assert _model.data.string == message.data['string']
def test_build_message_variant(self):
""" Test `build_message` with a variant property """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int
data = dict
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert hasattr(message_class, 'data')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi', integer=5, data={'hi': 'sup'})
message = message_class(string='hi', integer=5, data={'hi': 'sup'})
assert _model.string == message.string
assert _model.integer == message.integer
assert _model.data['hi'] == message.data['hi']
def test_build_message_explicit_field_args_kwargs(self):
""" Test `build_message` with an implementation of field args + kwargs """
class SimpleEnum(messages.Enum):
""" Enumerates colors! """
RED = 0x0
BLUE = 0x1
GREEN = 0x2
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
color = basestring, {
'field': ('EnumField', (SimpleEnum,), {'default': SimpleEnum.RED})}
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'color')
assert message_class.color.type is SimpleEnum
assert message_class().color is SimpleEnum.RED
def test_build_message_with_enum(self):
""" Test `build_message` with a message that contains an enum """
class Color(struct.BidirectionalEnum):
""" Sample enumeration of a bunch of colors. """
BLUE = 0x0
RED = 0x1
GREEN = 0x2
class SomeModel(model.Model):
""" Something involving colors. """
color = Color
name = str
message_class = protorpc.build_message(SomeModel)
assert hasattr(message_class, 'color')
assert hasattr(message_class, 'name')
assert message_class.color.type.BLUE is Color.BLUE
def test_build_message_repeated(self):
""" Test `build_message` with a repeated property """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int, {'repeated': True}
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert message_class.integer.repeated is True
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi', integer=[1, 2, 3])
message = message_class(string='hi', integer=[1, 2, 3])
assert _model.string == message.string
assert type(_model.integer) is list
assert type(message.integer) is messages.FieldList
assert len(_model.integer) == 3 and len(message.integer) == 3
def test_build_message_default(self):
""" Test `build_message` with a property that has a default value """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int, {'default': 10}
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi')
message = message_class(string='hi')
assert _model.string == message.string
assert _model.integer == message.integer
def test_build_message(self):
""" Test `build_message` with a basic `Model` """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi', integer=5)
message = message_class(string='hi', integer=5)
assert _model.string == message.string
assert _model.integer == message.integer
def test_build_message_submodel(self):
""" Test `build_message` with an embedded submodel """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = int
class SimpleContainer(model.Model):
""" Simple container message """
model = SimpleModel
message_class = protorpc.build_message(SimpleContainer)
assert hasattr(message_class, 'model')
assert message_class.__name__ == SimpleContainer.kind()
assert message_class.model.message_type.__name__ == SimpleModel.kind()
def test_build_message_skip_field(self):
""" Test `build_message` with an indication to skip a field """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = float, {'field': False}
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert not hasattr(message_class, 'integer')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi', integer=5.5)
message = message_class(string='hi')
assert _model.string == message.string
with self.assertRaises(AttributeError):
message.integer
def test_build_message_explicit_implementation_field(self):
""" Test `build_message` with a valid explicit implementation field """
class SimpleModel(model.Model):
""" Simple model message """
string = basestring
integer = float, {'field': 'IntegerField'}
message_class = protorpc.build_message(SimpleModel)
assert hasattr(message_class, 'string')
assert hasattr(message_class, 'integer')
assert message_class.__name__ == SimpleModel.kind()
_model = SimpleModel(string='hi', integer=5.5)
message = message_class(string='hi', integer=5)
assert _model.string == message.string
assert isinstance(_model.integer, float)
assert isinstance(message.integer, int)
