def test_module_root(self):
module_data_root = RwpersonDbYang.YangData_RwpersonDb()
module_data_root.person_list.add()
module_data_root.person_list[0].name = "Alice"
module_data_root.person_list[0].person_info.aadhar_id = "12345678"
module_data_root.person_list.add()
module_data_root.person_list[1].name = "Calvin"
module_data_root.person_list[1].person_info.aadhar_id = "45677888"
model = RwYang.Model.create_libncx()
module = model.load_module("rwperson-db")
xml_data = module_data_root.to_xml_v2(model, 1)
print(xml_data)
recreated_mdr = RwpersonDbYang.YangData_RwpersonDb()
recreated_mdr.from_xml_v2(model, xml_data)
print(recreated_mdr)
person_list = RwpersonDbYang.PersonList()
try:
person_list.from_xml_v2(model, xml_data)
except GLib.GError as e:
print(e)
pass
except e:
self.fail('Unexpected exception thrown:', e)
else:
self.fail('ExpectedException not thrown')
def setUp(self):
self._serializer = ProtoMessageSerializer(RwpersonDbYang,
RwpersonDbYang.Person)
self._sample_person = RwpersonDbYang.Person(name="Fred")
self._model = RwYang.model_create_libncx()
self._model.load_schema_ypbc(RwpersonDbYang.get_schema())
def test_flat_person_xml_conversion(self):
# Open rwperson-database yang model
yang = rw_peas.PeasPlugin('yangmodel_plugin-c', 'YangModelPlugin-1.0')
yang_model = yang.get_interface('Model')
yang_module = yang.get_interface('Module')
yang_node = yang.get_interface('Node')
yang_key = yang.get_interface('Key')
model = yang_model.alloc()
module = yang_model.load_module(model, "rwperson-db")
#populate the person
self.flat_person.name = "test-name"
self.flat_person.email = "*****@*****.**"
self.flat_person.employed = True
self.flat_person.id = 12345
self.flat_person.emergency_phone.number = "123-456-7890"
self.flat_person.emergency_phone.type_yang = 'WORK'
new_flat_phone = [
RwpersonDbYang.FlatPhoneNumber(),
RwpersonDbYang.FlatPhoneNumber()
]
new_flat_phone[0].number = '#1'
new_flat_phone[1].number = '#2'
self.flat_person.phone = new_flat_phone
# recreate a person using to_xml and from_xml methods
xml_str = self.flat_person.to_xml(model)
recreated_flat_person = RwpersonDbYang.FlatPerson()
recreated_flat_person.from_xml(model, xml_str)
print("Person : ", self.flat_person)
print("Recreated Person : ", recreated_flat_person)
# check the newly created person is identical
self.assertEqual(self.flat_person.name, recreated_flat_person.name)
self.assertEqual(self.flat_person.email, recreated_flat_person.email)
self.assertEqual(self.flat_person.employed,
recreated_flat_person.employed)
self.assertEqual(self.flat_person.id, recreated_flat_person.id)
self.assertEqual(self.flat_person.emergency_phone.number,
recreated_flat_person.emergency_phone.number)
self.assertEqual(self.flat_person.emergency_phone.type_yang,
recreated_flat_person.emergency_phone.type_yang)
self.assertEqual(len(self.flat_person.phone),
len(recreated_flat_person.phone))
for phone, recreated_phone in zip(self.flat_person.phone,
recreated_flat_person.phone):
self.assertEqual(phone.number, recreated_phone.number)
self.assertEqual(phone.type_yang, recreated_phone.type_yang)
flat_person = None
recreated_flat_person = None
new_flat_phone = None
def setUp(self):
self._serializer = ProtoMessageSerializer(
RwpersonDbYang,
RwpersonDbYang.Person,
RwProjectPersonDbYang,
RwProjectPersonDbYang.YangData_RwProject_Project_Person,
)
self._sample_person = RwpersonDbYang.Person(name="Fred")
self._project_person = RwProjectPersonDbYang.YangData_RwProject_Project_Person(
name="Fred")
self._model = RwYang.model_create_libyang()
self._model.load_schema_ypbc(RwpersonDbYang.get_schema())
def test_list_in_flat_person(self):
self.assertNotEqual(self.flat_person.phone, None)
self.assertEqual(len(self.flat_person.phone), 0)
new_phone_inline = [
RwpersonDbYang.FlatPhoneNumber(),
RwpersonDbYang.FlatPhoneNumber()
]
new_phone_inline[0].number = '#1'
new_phone_inline[1].number = '#2'
self.flat_person.phone = new_phone_inline
self.assertEqual(self.flat_person.phone[0], new_phone_inline[0])
self.assertEqual(self.flat_person.phone[1], new_phone_inline[1])
def test_pb_xml_rpc(self):
model = RwYang.Model.create_libncx()
module = model.load_module("rwperson-db")
rpci = RwpersonDbYang.DuplicateDBI()
rpci.target.name = "abc"
rpci.target.details.location = "192.168.2.1:9090/root/tmp"
rpci.target.details.timeout = 5000
xml_str = rpci.to_xml_v2(model)
print(xml_str)
rpco = RwpersonDbYang.DuplicateDBO()
rpco.target.name = "backup1"
rpco.target.result.timetaken = 1000
xml_str = rpco.to_xml_v2(model)
print(xml_str)
def _make_person():
person = RwpersonDbYang.Person()
person.name = "test-name"
person.email = "*****@*****.**"
person.employed = True
person.id = 12345
person.emergency_phone.number = "123-456-7890"
person.emergency_phone.type_yang = 'WORK'
new_phone = [RwpersonDbYang.PhoneNumber(), RwpersonDbYang.PhoneNumber()]
new_phone[0].number = '#1'
new_phone[1].number = '#2'
person.phone = new_phone
return person
def test_copy_from_person(self):
person1 = RwpersonDbYang.Person()
person1.name = "Alice"
person1.email = "*****@*****.**"
person1.employed = True
person1.id = 12345
person1.blob = bytearray([0x1, 0x2, 0x3, 0x0, 0x4])
person1.emergency_phone.number = "123-456-7890"
person1.phone.add()
person1.phone[0].number = '100'
person1.favourite.numbers = [10, 8]
person1.favourite.colors = ['blue', 'purple']
person1.favourite.places = ['LA', 'MA']
self.person.copy_from(person1)
self.assertEqual(self.person.name, "Alice")
self.assertEqual(self.person.email, "*****@*****.**")
self.assertTrue(self.person.employed)
self.assertEqual(self.person.id, 12345)
self.assertEqual(self.person.blob, bytearray([0x1, 0x2, 0x3, 0x0,
0x4]))
self.assertEqual(self.person.emergency_phone.number, "123-456-7890")
self.assertEqual(self.person.phone[0].number, '100')
self.assertEqual(self.person.favourite.numbers[0], 10)
self.assertEqual(self.person.favourite.numbers[1], 8)
self.assertEqual(self.person.favourite.colors[0], 'blue')
self.assertEqual(self.person.favourite.colors[1], 'purple')
self.assertEqual(self.person.favourite.places[0], 'LA')
self.assertEqual(self.person.favourite.places[1], 'MA')
def test_new_container_assignment_in_flat_person(self):
emergency_phone_inline = self.flat_person.emergency_phone
new_emergency_phone_inline = RwpersonDbYang.FlatPhoneNumber1()
new_emergency_phone_inline.number = '098-765-4321'
self.assertEqual(new_emergency_phone_inline.number, '098-765-4321')
# Check that person's emergency phone inline is updated
self.flat_person.emergency_phone = new_emergency_phone_inline
self.assertEqual(self.flat_person.emergency_phone.number,
'098-765-4321')
## Check that emergency_phone_inline no longer works
try:
emergency_phone_inline.number
except GLib.GError:
pass
except e:
self.fail('Unexpected exception thrown:', e)
else:
self.fail('ExpectedException not thrown')
# Check that new_emergency_phone now points to phone's memory
new_emergency_phone_inline.number = '123-456-7890'
self.assertEqual(self.flat_person.emergency_phone.number,
'123-456-7890')
def test_new_container_assignment_in_person(self):
new_emergency_phone = RwpersonDbYang.PhoneNumber1()
new_emergency_phone.number = '098-765-4321'
self.assertEqual(new_emergency_phone.number, '098-765-4321')
# Check that person's emergency phone is updated
self.person.emergency_phone = new_emergency_phone
self.assertEqual(self.person.emergency_phone.number, '098-765-4321')
def test_xml_v2(self):
xml_data = self.min_person.to_xml_v2(self.model)
print("XML Data: {0}".format(xml_data))
new_person = RwpersonDbYang.YangData_RwpersonDb_MinimalPerson()
new_person.from_xml_v2(self.model, xml_data)
self.compare_min_persons(self.min_person, new_person)
def test_keyspec_xpath(self):
xpath = "/ps:person/ps:phone[ps:number=\'1234\']"
schema = RwpersonDbYang.get_schema()
keyspec = RwKeyspec.path_from_xpath(schema, xpath, RwKeyspec.RwXpathType.KEYSPEC)
self.assertTrue(keyspec)
xpath_r = keyspec.to_xpath(schema)
self.assertTrue(xpath_r)
self.assertEqual(xpath_r, xpath)
print(xpath_r)
def test_keyspec_xpath(self):
xpath = "/ps:person/ps:phone[ps:number=\'1234\']"
schema = RwpersonDbYang.get_schema()
keyspec = RwKeyspec.path_from_xpath(schema, xpath, RwKeyspec.RwXpathType.KEYSPEC)
self.assertTrue(keyspec)
xpath_r = keyspec.to_xpath(schema)
self.assertTrue(xpath_r)
self.assertEqual(xpath_r, xpath)
print(xpath_r)
def setUp(self):
self._serializer = ProtoMessageSerializer(
RwpersonDbYang,
RwpersonDbYang.Person
)
self._sample_person = RwpersonDbYang.Person(name="Fred")
self._model = RwYang.model_create_libncx()
self._model.load_schema_ypbc(RwpersonDbYang.get_schema())
def test_person_protobuf_conversion(self):
self.person.name = "test-name"
self.person.email = "*****@*****.**"
self.person.employed = True
self.person.id = 12345
self.person.emergency_phone.number = "123-456-7890"
self.person.emergency_phone.type_yang = 'WORK'
new_phone = [
RwpersonDbYang.PhoneNumber(),
RwpersonDbYang.PhoneNumber()
]
new_phone[0].number = '#1'
new_phone[1].number = '#2'
self.person.phone = new_phone
# recreate a person using to_pbuf and from_pbuf methods
pbuf = self.person.to_pbuf()
recreated_person = RwpersonDbYang.Person()
recreated_person.from_pbuf(pbuf)
print("Person : ", self.person)
print("Recreated Person : ", recreated_person)
# check the newly created person is identical
self.assertEqual(self.person.name, recreated_person.name)
self.assertEqual(self.person.email, recreated_person.email)
self.assertEqual(self.person.employed, recreated_person.employed)
self.assertEqual(self.person.id, recreated_person.id)
self.assertEqual(self.person.emergency_phone.number,
recreated_person.emergency_phone.number)
self.assertEqual(self.person.emergency_phone.type_yang,
recreated_person.emergency_phone.type_yang)
self.assertEqual(len(self.person.phone), len(recreated_person.phone))
for phone, recreated_phone in zip(self.person.phone,
recreated_person.phone):
self.assertEqual(phone.number, recreated_phone.number)
self.assertEqual(phone.type_yang, recreated_phone.type_yang)
##
# Need a testcase for this.
##
ptr = recreated_person.to_ptr()
def test_zombie_child(self):
person_fav = RwpersonDbYang.Person_Favourite()
person_fav.numbers = [100, 101]
person_fav.colors = ('red', 'green')
person_fav.places = ['bangalore', 'boston']
self.person.favourite = person_fav
person_fav_new = RwpersonDbYang.Person_Favourite()
person_fav_new.numbers = [200, 202]
person_fav_new.colors = ('red', 'purple')
person_fav_new.places = ['LA', 'boston']
self.person.favourite = person_fav_new
#person_fav should become zombie now.
try:
print(person_fav)
except GLib.GError as e:
print(e)
pass
except e:
self.fail('Unexpected exception thrown:', e)
else:
self.fail('ExpectedException not thrown')
def test_person_json_conversion(self):
if sys.version_info < (3, 0):
# to_json is python3 only
return
model, module = _load_person_db()
person = _make_person()
# recreate a person using to_json and from_json methods
json_str = person.to_json(model)
recreated_person = RwpersonDbYang.Person()
recreated_person.from_json(model, json_str)
self._assert_people_are_equal(person, recreated_person)
def setUp(self):
from gi.repository import RwYang
self.min_person = RwpersonDbYang.YangData_RwpersonDb_MinimalPerson()
self.model = RwYang.Model.create_libncx()
self.module = self.model.load_module("rwperson-db")
self.min_person.set_name("Foo")
self.min_person.set_employed(False)
self.min_person.set_email("*****@*****.**")
self.min_person.set_nationality("zombie")
tmp_addr = self.min_person.create_address()
tmp_addr.set_city("sine")
tmp_addr.set_state("xyz")
tmp_addr.set_street("jump")
self.min_person.set_address(tmp_addr)
def setUp(self):
self.person = RwpersonDbYang.Person()
self.flat_person = RwpersonDbYang.FlatPerson()
def test_to_json_string_invalid_type(self):
with self.assertRaises(TypeError):
self._serializer.to_json_string(
RwpersonDbYang.FlatPerson(name="bob"))
def test_nullable(self):
person = RwpersonDbYang.Person()
person.name = "jeff"
person.emergency_phone.type_yang = 'WORK'
person.blob = bytearray([0x1, 0x2, 0x3, 0x0, 0x4])
self.assertTrue(person.has_field('name'))
try:
person.name = None
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
pass
self.assertFalse(person.has_field('name'))
self.assertTrue(person.emergency_phone.has_field('type'))
try:
person.emergency_phone.type_yang = None
except TypeError:
pass
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
self.fail('ExpectedException not thrown')
self.assertTrue(person.emergency_phone.has_field('type'))
self.assertTrue(person.has_field('emergency_phone'))
try:
person.emergency_phone = None
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
pass
self.assertFalse(person.has_field('emergency_phone'))
self.assertTrue(person.has_field('blob'))
try:
person.blob = None
except TypeError:
pass
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
self.fail('ExpectedException not thrown')
self.assertTrue(person.has_field('blob'))
flat_person = RwpersonDbYang.FlatPerson()
flat_person.name = "jeff"
flat_person.emergency_phone.type_yang = 'WORK'
flat_person.blob = bytearray([0x1, 0x2, 0x3, 0x0, 0x4])
self.assertTrue(flat_person.has_field('name'))
try:
flat_person.name = None
except TypeError:
pass
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
self.fail('ExpectedException not thrown')
self.assertTrue(flat_person.has_field('name'))
self.assertTrue(flat_person.emergency_phone.has_field('type'))
try:
flat_person.emergency_phone.type_yang = None
except TypeError:
pass
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
self.fail('ExpectedException not thrown')
self.assertTrue(flat_person.emergency_phone.has_field('type'))
self.assertTrue(flat_person.has_field('emergency_phone'))
try:
flat_person.emergency_phone = None
except TypeError:
pass
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
self.fail('ExpectedException not thrown')
self.assertTrue(flat_person.has_field('emergency_phone'))
self.assertTrue(flat_person.has_field('blob'))
try:
flat_person.blob = None
except TypeError:
pass
except Exception as e:
self.fail('Unexpected exception thrown: ' + str(e))
else:
self.fail('ExpectedException not thrown')
self.assertTrue(flat_person.has_field('blob'))
