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 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'))