class SqliteTestStruct(rdf_structs.RDFProtoStruct): """Custom struct for testing schema generation.""" type_description = type_info.TypeDescriptorSet( rdf_structs.ProtoString(name="string_field", field_number=1), rdf_structs.ProtoBinary(name="bytes_field", field_number=2), rdf_structs.ProtoUnsignedInteger(name="uint_field", field_number=3), rdf_structs.ProtoSignedInteger(name="int_field", field_number=4), rdf_structs.ProtoFloat(name="float_field", field_number=5), rdf_structs.ProtoDouble(name="double_field", field_number=6), rdf_structs.ProtoEnum(name="enum_field", field_number=7, enum_name="EnumField", enum={ "FIRST": 1, "SECOND": 2 }), rdf_structs.ProtoBoolean(name="bool_field", field_number=8), rdf_structs.ProtoRDFValue(name="urn_field", field_number=9, rdf_type="RDFURN"), rdf_structs.ProtoRDFValue(name="time_field", field_number=10, rdf_type="RDFDatetime"), rdf_structs.ProtoRDFValue(name="time_field_seconds", field_number=11, rdf_type="RDFDatetimeSeconds"), rdf_structs.ProtoRDFValue(name="duration_field", field_number=12, rdf_type="Duration"), rdf_structs.ProtoEmbedded(name="embedded_field", field_number=13, nested=TestEmbeddedStruct))
class LateBindingTest(structs.RDFProtoStruct): type_description = type_info.TypeDescriptorSet( # A nested protobuf referring to an undefined type. structs.ProtoEmbedded(name="nested", field_number=1, nested="UndefinedYet"), structs.ProtoRDFValue(name="rdfvalue", field_number=6, rdf_type="UndefinedRDFValue", description="An undefined RDFValue field."), # A repeated late bound field. structs.ProtoList( structs.ProtoRDFValue(name="repeated", field_number=7, rdf_type="UndefinedRDFValue2", description="An undefined RDFValue field.")), )
def testSimpleTypeAssignment(self): sample = rdf_client.StatEntry() sample.AddDescriptor( rdf_structs.ProtoRDFValue( name="test", field_number=45, default=rdfvalue.RDFInteger(0), rdf_type=rdfvalue.RDFInteger)) self.assertIsInstance(sample.test, rdfvalue.RDFInteger) # Can we assign an RDFValue instance? sample.test = rdfvalue.RDFInteger(5) self.assertEqual(sample.test, 5) # Check that bare values can be coerced. sample.test = 6 self.assertIsInstance(sample.test, rdfvalue.RDFInteger) self.assertEqual(sample.test, 6) # Assign an enum. sample.registry_type = sample.RegistryType.REG_DWORD self.assertEqual(sample.registry_type, sample.RegistryType.REG_DWORD) sample.registry_type = rdf_client.StatEntry.RegistryType.REG_SZ self.assertEqual(sample.registry_type, sample.RegistryType.REG_SZ) # We can also assign the string value. sample.registry_type = "REG_QWORD" self.assertEqual(sample.registry_type, sample.RegistryType.REG_QWORD) # Check that coercing works. sample.test = "10" self.assertEqual(sample.test, 10) # Assign an RDFValue which can not be coerced. self.assertRaises(type_info.TypeValueError, setattr, sample, "test", rdfvalue.RDFString("hello"))
class TestStruct(structs.RDFProtoStruct): """A test struct object.""" type_description = type_info.TypeDescriptorSet( structs.ProtoString( name="foobar", field_number=1, default="string", description="A string value", labels=[structs.SemanticDescriptor.Labels.HIDDEN]), structs.ProtoUnsignedInteger( name="int", field_number=2, default=5, description="An integer value"), structs.ProtoList( structs.ProtoString( name="repeated", field_number=3, description="A repeated string value")), # We can serialize an arbitrary RDFValue. This will be serialized into a # binary string and parsed on demand. structs.ProtoRDFValue( name="urn", field_number=6, default=rdfvalue.RDFURN("www.google.com"), rdf_type="RDFURN", description="An arbitrary RDFValue field."), structs.ProtoEnum( name="type", field_number=7, enum_name="Type", enum=dict(FIRST=1, SECOND=2, THIRD=3), default=3, description="An enum field"), structs.ProtoFloat( name="float", field_number=8, description="A float number", default=1.1),)