def test_has_value_assigned_repeated(self): class Foo(messages.Message): pete = messages.StringField(repeated=True) message = to_dict.decode_message(Foo, {"pete": []}) self.assertTrue(message.has_value_assigned('pete')) message = to_dict.decode_message(Foo, {"pete": ["sat"]}) self.assertTrue(message.has_value_assigned('pete')) message = to_dict.decode_message(Foo, {"pete": ["sat", "in", "a", "boat"]}) self.assertTrue(message.has_value_assigned('pete'))
def test_untyped_field_decode(self): class Foo(messages.Message): bar = messages.UntypedField() f = Foo() self.assertEquals(f, to_dict.decode_message(Foo, {})) f = Foo() f.bar = 123 self.assertEquals(f, to_dict.decode_message(Foo, {"bar": 123})) f = Foo() f.bar = "meow" self.assertEquals(f, to_dict.decode_message(Foo, {"bar": "meow"})) f = Foo() f.bar = True self.assertEquals(f, to_dict.decode_message(Foo, {"bar": True})) f = Foo() f.bar = 1.23 self.assertEquals(f, to_dict.decode_message(Foo, {"bar": 1.23})) f = Foo() f.bar = 1.23 self.assertEquals(f, to_dict.decode_message(Foo, {"bar": 1.23})) f = Foo() f.bar = None self.assertEquals(f, to_dict.decode_message(Foo, {"bar": None})) f = Foo() f.bar = [[123, 1.23, "woof", True], "meow"] self.assertEquals(f, to_dict.decode_message(Foo, {"bar": [[123, 1.23, "woof", True], "meow"]}))
def testUnrecognizedFieldVariants(self): """Test that unrecognized fields are mapped to the right variants.""" for encoded, expected_variant in (({ "an_integer": 1, "unknown_val": 2 }, messages.Variant.INT64), ({ "an_integer": 1, "unknown_val": 2.0 }, messages.Variant.DOUBLE), ({ "an_integer": 1, "unknown_val": "string value" }, messages.Variant.STRING), ({ "an_integer": 1, "unknown_val": [1, 2, 3] }, messages.Variant.INT64), ({ "an_integer": 1, "unknown_val": [1, 2.0, 3] }, messages.Variant.DOUBLE), ({ "an_integer": 1, "unknown_val": [1, "foo", 3] }, messages.Variant.STRING), ({ "an_integer": 1, "unknown_val": True }, messages.Variant.BOOL)): decoded = to_dict.decode_message(MyMessage, encoded) self.assertEqual(decoded.an_integer, 1) self.assertEqual(1, len(decoded.all_unrecognized_fields())) self.assertEqual('unknown_val', decoded.all_unrecognized_fields()[0]) _, decoded_variant = decoded.get_unrecognized_field_info( 'unknown_val') self.assertEqual(expected_variant, decoded_variant)
def testProtodictUnrecognizedNull(self): """Test that unrecognized fields that are None are skipped.""" decoded = to_dict.decode_message( MyMessage, {"an_integer": 1, "unrecognized_null": None}) self.assertEquals(decoded.an_integer, 1) self.assertEquals(decoded.all_unrecognized_fields(), [])
def test_untyped_field_repeated_decode(self): class Foo(messages.Message): bar = messages.UntypedField(repeated=True) f = Foo() f.bar = [123, "woof", 1.23, True] self.assertEquals(f, to_dict.decode_message(Foo, {"bar": [123, "woof", 1.23, True]}))
def testEmptyList(self): """Test that empty lists are not ignored.""" m = MyMessage() m.a_repeated = [] self.assertEquals(m, to_dict.decode_message(MyMessage, {"a_repeated": []}))
def testNullValues(self): """Test that null values overwrite existing values.""" m = MyMessage() m.an_integer = None m.a_nested = None self.assertEquals(m, to_dict.decode_message(MyMessage, ({"an_integer": None, "a_nested": None})))
def testNumericEnumeration(self): """Test that numbers work for enum values.""" message = to_dict.decode_message(MyMessage, {"an_enum": 2}) expected_message = MyMessage() expected_message.an_enum = MyMessage.Color.GREEN self.assertEqual(expected_message, message)
def test_untyped_field_repeated_decode(self): class Foo(messages.Message): bar = messages.UntypedField(repeated=True) f = Foo() f.bar = [123, "woof", 1.23, True] self.assertEqual( f, to_dict.decode_message(Foo, {"bar": [123, "woof", 1.23, True]}))
def testNumericEnumeration(self): """Test that numbers work for enum values.""" message = to_dict.decode_message(MyMessage, {"an_enum": 2}) expected_message = MyMessage() expected_message.an_enum = MyMessage.Color.GREEN self.assertEquals(expected_message, message)
def testProtodictUnrecognizedNull(self): """Test that unrecognized fields that are None are skipped.""" decoded = to_dict.decode_message(MyMessage, { "an_integer": 1, "unrecognized_null": None }) self.assertEqual(decoded.an_integer, 1) self.assertEqual(decoded.all_unrecognized_fields(), [])
def testProtodictUnrecognizedFieldName(self): """Test that unrecognized fields are saved and can be accessed.""" decoded = to_dict.decode_message(MyMessage, ({"an_integer": 1, "unknown_val": 2})) self.assertEquals(decoded.an_integer, 1) self.assertEquals(1, len(decoded.all_unrecognized_fields())) self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0]) self.assertEquals((2, messages.Variant.INT64), decoded.get_unrecognized_field_info('unknown_val'))
def test_has_value_assigned(self): class Foo(messages.Message): not_set = messages.StringField() set_null = messages.StringField() message = to_dict.decode_message(Foo, {"set_null": None}) self.assertFalse(message.has_value_assigned('not_set')) self.assertTrue(message.has_value_assigned('set_null')) self.assertIsNone(message.not_set) self.assertIsNone(message.set_null)
def test_explicit_field_name_round_trip(self): class Foo(messages.Message): bob = messages.StringField(name="robert") ryan = messages.StringField() f = Foo(bob="smith", ryan="morlok") m = to_dict.decode_message(Foo, to_dict.encode_message(f)) self.assertEquals("smith", m.bob) self.assertEquals("morlok", m.ryan)
def test_explicit_field_name_round_trip(self): class Foo(messages.Message): bob = messages.StringField(name="robert") ryan = messages.StringField() f = Foo(bob="smith", ryan="morlok") m = to_dict.decode_message(Foo, to_dict.encode_message(f)) self.assertEqual("smith", m.bob) self.assertEqual("morlok", m.ryan)
def testProtodictUnrecognizedFieldName(self): """Test that unrecognized fields are saved and can be accessed.""" decoded = to_dict.decode_message(MyMessage, ({ "an_integer": 1, "unknown_val": 2 })) self.assertEqual(decoded.an_integer, 1) self.assertEqual(1, len(decoded.all_unrecognized_fields())) self.assertEqual('unknown_val', decoded.all_unrecognized_fields()[0]) self.assertEqual((2, messages.Variant.INT64), decoded.get_unrecognized_field_info('unknown_val'))
def testNullValues(self): """Test that null values overwrite existing values.""" m = MyMessage() m.an_integer = None m.a_nested = None self.assertEqual( m, to_dict.decode_message(MyMessage, ({ "an_integer": None, "a_nested": None })))
def testProtodictUnrecognizedFieldNumber(self): """Test that unrecognized fields are saved and can be accessed.""" decoded = to_dict.decode_message(MyMessage, {"an_integer": 1, "1001": "unknown", "-123": "negative", "456_mixed": 2}) self.assertEquals(decoded.an_integer, 1) self.assertEquals(3, len(decoded.all_unrecognized_fields())) self.assertIn(1001, decoded.all_unrecognized_fields()) self.assertEquals(('unknown', messages.Variant.STRING), decoded.get_unrecognized_field_info(1001)) self.assertIn('-123', decoded.all_unrecognized_fields()) self.assertEquals(('negative', messages.Variant.STRING), decoded.get_unrecognized_field_info('-123')) self.assertIn('456_mixed', decoded.all_unrecognized_fields()) self.assertEquals((2, messages.Variant.INT64), decoded.get_unrecognized_field_info('456_mixed'))
def testDecodeRepeatedDateTimeMsInteger(self): message = to_dict.decode_message(MyMessage, {"a_repeated_datetime_ms_integer": [ datetime.datetime(2012, 9, 30, 15, 31, 50, 262000), datetime.datetime(2010, 1, 21, 9, 52), datetime.datetime(2000, 1, 1, 1, 0, 59, 999999) ]}) expected_message = MyMessage( a_repeated_datetime_ms_integer=[ datetime.datetime(2012, 9, 30, 15, 31, 50, 262000), datetime.datetime(2010, 1, 21, 9, 52), datetime.datetime(2000, 1, 1, 1, 0, 59, 999999)]) self.assertEquals(expected_message, message)
def testConvertStringToNumbers(self): """Test that strings passed to integer fields are converted.""" message = to_dict.decode_message(MyMessage, {"an_integer": "10", "a_float": "3.5", "a_repeated": ["1", "2"], "a_repeated_float": ["1.5", "2", 10] }) self.assertEquals(MyMessage(an_integer=10, a_float=3.5, a_repeated=[1, 2], a_repeated_float=[1.5, 2.0, 10.0]), message)
def test_explicit_field_name(self): class Foo(messages.Message): bob = messages.StringField(name="robert") ryan = messages.StringField() m = to_dict.decode_message(Foo, {"robert": "smith", "ryan": "morlok"}) self.assertEquals("smith", m.bob) self.assertEquals("morlok", m.ryan) f = Foo() f.bob = "smith" f.ryan = "morlok" self.assertEquals({"robert": "smith", "ryan": "morlok"}, to_dict.encode_message(f))
def test_explicit_field_name_repeated(self): class Foo(messages.Message): bob = messages.StringField(name="robert", repeated=True) ryan = messages.StringField() m = to_dict.decode_message(Foo, {"robert": ["smith", "jones"], "ryan": "morlok"}) self.assertEquals(["smith", "jones"], m.bob) self.assertEquals("morlok", m.ryan) f = Foo() f.bob = ["smith", "jones"] f.ryan = "morlok" self.assertEquals({"robert": ["smith", "jones"], "ryan": "morlok"}, to_dict.encode_message(f))
def testConvertStringToNumbers(self): """Test that strings passed to integer fields are converted.""" message = to_dict.decode_message( MyMessage, { "an_integer": "10", "a_float": "3.5", "a_repeated": ["1", "2"], "a_repeated_float": ["1.5", "2", 10] }) self.assertEqual( MyMessage(an_integer=10, a_float=3.5, a_repeated=[1, 2], a_repeated_float=[1.5, 2.0, 10.0]), message)
def testDecodeRepeatedDateTimeMsInteger(self): message = to_dict.decode_message( MyMessage, { "a_repeated_datetime_ms_integer": [ datetime.datetime(2012, 9, 30, 15, 31, 50, 262000), datetime.datetime(2010, 1, 21, 9, 52), datetime.datetime(2000, 1, 1, 1, 0, 59, 999999) ] }) expected_message = MyMessage(a_repeated_datetime_ms_integer=[ datetime.datetime(2012, 9, 30, 15, 31, 50, 262000), datetime.datetime(2010, 1, 21, 9, 52), datetime.datetime(2000, 1, 1, 1, 0, 59, 999999) ]) self.assertEqual(expected_message, message)
def test_explicit_field_name(self): class Foo(messages.Message): bob = messages.StringField(name="robert") ryan = messages.StringField() m = to_dict.decode_message(Foo, {"robert": "smith", "ryan": "morlok"}) self.assertEqual("smith", m.bob) self.assertEqual("morlok", m.ryan) f = Foo() f.bob = "smith" f.ryan = "morlok" self.assertEqual({ "robert": "smith", "ryan": "morlok" }, to_dict.encode_message(f))
def testDecodeRepeatedUUID(self): from uuid import UUID message = to_dict.decode_message( MyMessage, { "a_repeated_uuid": [ UUID("06335e84-2872-4914-8c5d-3ed07d2a2f16"), UUID("16335e84-2872-4914-8c5d-3ed07d2a2f16"), UUID("26335e84-2872-4914-8c5d-3ed07d2a2f16"), ] }) expected_message = MyMessage(a_repeated_uuid=[ UUID("06335e84-2872-4914-8c5d-3ed07d2a2f16"), UUID("16335e84-2872-4914-8c5d-3ed07d2a2f16"), UUID("26335e84-2872-4914-8c5d-3ed07d2a2f16"), ]) self.assertEqual(expected_message, message)
def testUnrecognizedFieldVariants(self): """Test that unrecognized fields are mapped to the right variants.""" for encoded, expected_variant in ( ({"an_integer": 1, "unknown_val": 2}, messages.Variant.INT64), ({"an_integer": 1, "unknown_val": 2.0}, messages.Variant.DOUBLE), ({"an_integer": 1, "unknown_val": "string value"}, messages.Variant.STRING), ({"an_integer": 1, "unknown_val": [1, 2, 3]}, messages.Variant.INT64), ({"an_integer": 1, "unknown_val": [1, 2.0, 3]}, messages.Variant.DOUBLE), ({"an_integer": 1, "unknown_val": [1, "foo", 3]}, messages.Variant.STRING), ({"an_integer": 1, "unknown_val": True}, messages.Variant.BOOL)): decoded = to_dict.decode_message(MyMessage, encoded) self.assertEquals(decoded.an_integer, 1) self.assertEquals(1, len(decoded.all_unrecognized_fields())) self.assertEquals('unknown_val', decoded.all_unrecognized_fields()[0]) _, decoded_variant = decoded.get_unrecognized_field_info('unknown_val') self.assertEquals(expected_variant, decoded_variant)
def testProtodictUnrecognizedFieldNumber(self): """Test that unrecognized fields are saved and can be accessed.""" decoded = to_dict.decode_message(MyMessage, { "an_integer": 1, "1001": "unknown", "-123": "negative", "456_mixed": 2 }) self.assertEqual(decoded.an_integer, 1) self.assertEqual(3, len(decoded.all_unrecognized_fields())) self.assertIn(1001, decoded.all_unrecognized_fields()) self.assertEqual(('unknown', messages.Variant.STRING), decoded.get_unrecognized_field_info(1001)) self.assertIn('-123', decoded.all_unrecognized_fields()) self.assertEqual(('negative', messages.Variant.STRING), decoded.get_unrecognized_field_info('-123')) self.assertIn('456_mixed', decoded.all_unrecognized_fields()) self.assertEqual((2, messages.Variant.INT64), decoded.get_unrecognized_field_info('456_mixed'))
def test_explicit_field_name_repeated(self): class Foo(messages.Message): bob = messages.StringField(name="robert", repeated=True) ryan = messages.StringField() m = to_dict.decode_message(Foo, { "robert": ["smith", "jones"], "ryan": "morlok" }) self.assertEqual(["smith", "jones"], m.bob) self.assertEqual("morlok", m.ryan) f = Foo() f.bob = ["smith", "jones"] f.ryan = "morlok" self.assertEqual({ "robert": ["smith", "jones"], "ryan": "morlok" }, to_dict.encode_message(f))
def test_untyped_field_decode(self): class Foo(messages.Message): bar = messages.UntypedField() f = Foo() self.assertEqual(f, to_dict.decode_message(Foo, {})) f = Foo() f.bar = 123 self.assertEqual(f, to_dict.decode_message(Foo, {"bar": 123})) f = Foo() f.bar = "meow" self.assertEqual(f, to_dict.decode_message(Foo, {"bar": "meow"})) f = Foo() f.bar = True self.assertEqual(f, to_dict.decode_message(Foo, {"bar": True})) f = Foo() f.bar = 1.23 self.assertEqual(f, to_dict.decode_message(Foo, {"bar": 1.23})) f = Foo() f.bar = 1.23 self.assertEqual(f, to_dict.decode_message(Foo, {"bar": 1.23})) f = Foo() f.bar = None self.assertEqual(f, to_dict.decode_message(Foo, {"bar": None})) f = Foo() f.bar = [[123, 1.23, "woof", True], "meow"] self.assertEqual( f, to_dict.decode_message( Foo, {"bar": [[123, 1.23, "woof", True], "meow"]}))
def test_repeated_value_null_not_allowed(self): class Foo(messages.Message): pete = messages.StringField(repeated=True) self.assertRaises(messages.ValidationError, lambda: to_dict.decode_message(Foo, {"pete": None}))
def testDecodeCustom(self): message = to_dict.decode_message(MyMessage, {"a_custom": 1}) self.assertEquals(MyMessage(a_custom=1), message)
def testDecodeRepeatedCustom(self): message = to_dict.decode_message( MyMessage, {"a_repeated_custom": [1, 2, 3]}) self.assertEquals(MyMessage(a_repeated_custom=[1, 2, 3]), message)
def testDecodeCustom(self): message = to_dict.decode_message(MyMessage, {"a_custom": 1}) self.assertEqual(MyMessage(a_custom=1), message)
def testDecodeRepeatedCustom(self): message = to_dict.decode_message(MyMessage, {"a_repeated_custom": [1, 2, 3]}) self.assertEqual(MyMessage(a_repeated_custom=[1, 2, 3]), message)
def testEmptyList(self): """Test that empty lists are not ignored.""" m = MyMessage() m.a_repeated = [] self.assertEqual(m, to_dict.decode_message(MyMessage, {"a_repeated": []}))