def __init__(self, is_dbg_test): self.my_args = dispArgs() self.my_args.cfgdb = swsssdk.ConfigDBConnector() self.my_args.cfgdb.connect() self.my_args.appdb = swsssdk.SonicV2Connector(host='127.0.0.1') self.my_args.appdb.connect(self.my_args.appdb.APPL_DB) self.my_args.appdb.connect(self.my_args.appdb.COUNTERS_DB) self.my_args.appdb.connect(self.my_args.appdb.ASIC_DB) # create the full yang tree # for performance, only update the tree node requested self.oc_yph = YANGPathHelper() for k in ocTable.keys(): if ocTable[k]["cls"]: ocTable[k]["cls"](path_helper=self.oc_yph) # create obj for "/" to only return subtree of depth 1 openconfig_root_dpt_1(self.oc_yph) # create all interfaces to speed up processing request for interfaces later util_interface.interface_create_all_infs(self.oc_yph, is_dbg_test, self.my_args) # create default network instance util_nwi.nwi_create_dflt_nwi(self.oc_yph, is_dbg_test) # create default objects util_qos.qos_create_dflt_obj(self.oc_yph, is_dbg_test)
def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) err = None try: globals()["bindings"] = importlib.import_module("bindings") except ImportError as e: err = e self.assertIs(err, None) self.path_helper = YANGPathHelper() self.instance_a = bindings.root_tc04_a(path_helper=self.path_helper) self.instance_b = bindings.root_tc04_b(path_helper=self.path_helper)
def __init__(self, is_dbg_test): self.my_args = dispArgs() self.my_args.cfgdb = swsssdk.ConfigDBConnector() self.my_args.cfgdb.connect() self.my_args.appdb = swsssdk.SonicV2Connector(host='127.0.0.1') self.my_args.appdb.connect(self.my_args.appdb.APPL_DB) self.my_args.appdb.connect(self.my_args.appdb.COUNTERS_DB) self.my_args.appdb.connect(self.my_args.appdb.ASIC_DB) # check if port table is ready is_pcfg_done = False chk_cnt = 0 while True: pcfg_val = self.my_args.appdb.get_all(self.my_args.appdb.APPL_DB, "PORT_TABLE:PortConfigDone") is_pcfg_done = pcfg_val != None chk_cnt += 1 if is_pcfg_done or chk_cnt % 3 == 1: util_utl.utl_log( "PORT TABLE was%sready...(%s)" % ([" not ", " "][is_pcfg_done], chk_cnt), logging.CRITICAL) if is_pcfg_done: break time.sleep(10) # create the full yang tree # for performance, only update the tree node requested self.oc_yph = YANGPathHelper() for k in ocTable.keys(): if ocTable[k]["cls"]: ocTable[k]["cls"](path_helper = self.oc_yph) # create obj for "/" to only return subtree of depth 1 openconfig_root_dpt_1(self.oc_yph) # create all interfaces to speed up processing request for interfaces later util_interface.interface_create_all_infs(self.oc_yph, is_dbg_test, self.my_args) # create default network instance util_nwi.nwi_create_dflt_nwi(self.oc_yph, is_dbg_test) # create default objects util_qos.qos_create_dflt_obj(self.oc_yph, is_dbg_test) # check if new teammgrd is used test_cmd = 'docker run --rm=true --privileged=true --entrypoint="/bin/bash" "docker-teamd" -c "[ -f /usr/bin/teammgrd ]"' util_interface.IS_NEW_TEAMMGRD = util_utl.utl_execute_cmd(test_cmd)
def test_005_handle_multiple_set_path(self): server_ph = YANGPathHelper() s = simple_device(path_helper=server_ph) c = simple_device() c.system.config.hostname = "rtr0.lhr.uk" c.system.ntp.config.enabled = True operations = [ PyNMSConfigOperation(c.system.config), PyNMSConfigOperation(c.system.ntp) ] set_msg = PyNMSClientGRPCMethods.generate_set_message(operations, request_id=42) ret_msg = PyNMSServerGRPCMethods.service_set_request( set_msg, server_ph) self.assertEqual(ret_msg.request_id, 42) self.assertEqual(ret_msg.response_code, 0) self.assertEqual(pynms_rpc_pb2.RPCResponse.Name(ret_msg.response_code), 'OK') self.assertEqual(ret_msg.message, "") self.assertEqual(s.system.config.hostname, "rtr0.lhr.uk") self.assertEqual(s.system.ntp.config.enabled, True) del server_ph
def test_007_handle_failed_transaction(self): server_ph = YANGPathHelper() s = simple_device(path_helper=server_ph) set_msg = self._build_invalid_set_message(42, [{ "path": "/system/config/hostname", "json": "'rtr0.lhr.uk'" }, { "path": "/system/ntp/config", "json": { "config": { "enabled": 42 } } }]) ret_msg = PyNMSServerGRPCMethods.service_set_request( set_msg, server_ph) self.assertEqual(ret_msg.request_id, 42) self.assertEqual(ret_msg.response_code, 4) self.assertEqual(pynms_rpc_pb2.RPCResponse.Name(ret_msg.response_code), 'INVALID_CONFIGURATION') self.assertEqual(s.system.config.hostname, '') del server_ph
def t1_add_retr_object_plain(tree=False): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() obj_one = TestObject("t1_ObjOneTest") tree.register(["obj_one"], obj_one) retr_obj = tree.get(["obj_one"]) assert len(retr_obj) == 1, ("retrieved path matched the wrong number " + "of objects (%d != 1)" % (len(retr_obj))) assert isinstance(retr_obj[0], TestObject), ("retrieved object was not " + "the correct class") assert retr_obj[0].name() == "t1_ObjOneTest", ("retrieved object had an " + "invalid name specified (%s != t1_ObjOneTest)" % retr_obj.name()) if del_tree: del tree
def t1_currentref(yobj, tree=False): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() for i in [(1, 2), (3, 4), (5, 6)]: yobj.src_list.add("%s %s" % i) yobj.referencing_list.add(1) e = False try: yobj.referencing_list[1].source_val = "1" yobj.referencing_list[1].reference = "2" except ValueError: e = True assert e is False, "incorrectly rejected valid reference" assert yobj.src_list["1 2"].referenced == "1", \ "referenced value was incorrectly set" assert yobj.src_list["1 2"].value == "2", \ "referenced value was incorrectly set" if del_tree: del yhelper
def test_002_replace_interfaces(self): server_ph = YANGPathHelper() s = openconfig_interfaces(path_helper=server_ph) logger = logging.getLogger('PyNMSGPRC_OCMessageTests_Interfaces') logger.addHandler(logging.NullHandler()) gi0 = s.interfaces.interface.add("gi0/0/0") subint0 = gi0.subinterfaces.subinterface.add(0) ip4 = subint0.ipv4.addresses.address.add("192.0.2.1") ip4.config.prefix_length = 24 ocif = openconfig_interfaces() gi0 = ocif.interfaces.interface.add("gi0/0/0") subint0 = gi0.subinterfaces.subinterface.add(0) ip6 = subint0.ipv6.addresses.address.add("2001:db8::1") ip6.config.prefix_length = 64 transaction = [PyNMSConfigOperation(ocif.interfaces, 'REPLACE_CONFIG')] set_msg = PyNMSClientGRPCMethods.generate_set_message(transaction) ret_msg = PyNMSServerGRPCMethods.service_set_request(set_msg, server_ph, logger=logger) print s.interfaces.get(filter=True)
def test_001_get_interfaces(self): server_ph = YANGPathHelper() s = openconfig_interfaces(path_helper=server_ph) gi0 = s.interfaces.interface.add(u"gi0/0/0") subint0 = gi0.subinterfaces.subinterface.add(0) ip4 = subint0.ipv4.addresses.address.add(u"192.0.2.1") ip4.config.prefix_length = 24 ip6 = subint0.ipv6.addresses.address.add(u"2001:db8::1") ip6.config.prefix_length = 64 logger = logging.getLogger('PyNMSGPRC_OCMessageTests_Interfaces') logger.addHandler(logging.NullHandler()) get_msg = PyNMSClientGRPCMethods.generate_get_message(["/interfaces"], 42) ret_msg = PyNMSServerGRPCMethods.service_get_request(get_msg, server_ph, logger=logger) print ret_msg # # TODO: assertions # del server_ph
def test_003_handle_get_multiple_paths(self): server_ph = YANGPathHelper() s = simple_device(path_helper=server_ph) s.system.config.hostname = "rtr0.lhr.uk" s.system.config.domain_name = "test.jiveip.net" s.system.ntp.config.enabled = True get_msg = PyNMSClientGRPCMethods.generate_get_message( ["/system/config", "/system/config/hostname"], 0) ret_msg = PyNMSServerGRPCMethods.service_get_request( get_msg, server_ph) self.assertEqual(ret_msg.request_id, 0) self.assertEqual(ret_msg.response_code, 0) self.assertEqual(len(ret_msg.response), 2) expected_results = [("/system/config", { u'simple-device:hostname': u'rtr0.lhr.uk', u'simple-device:domain-name': u'test.jiveip.net' }), ("/system/config/hostname", u'rtr0.lhr.uk')] for returned, expected in zip(ret_msg.response, expected_results): self.assertEqual(returned.path, expected[0]) err = None try: json_returned = json.loads(returned.value) except Exception as e: err = e self.assertIsNone(err) self.assertEqual(json_returned, expected[1]) del server_ph
class JSONSerialiseTests(PyangBindTestCase): yang_files = ["json-serialise.yang"] pyang_flags = ["--use-xpathhelper"] def setUp(self): self.yang_helper = YANGPathHelper() self.serialise_obj = self.bindings.json_serialise(path_helper=self.yang_helper) def test_serialise_container(self): self.serialise_obj.two.string_test = "twenty-two" with open(os.path.join(os.path.dirname(__file__), "json", "container.json"), "r") as fp: self.assertEqual( json.loads(dumps(self.yang_helper.get("/two")[0])), json.load(fp), "Invalid output returned when serialising a container.", ) def test_full_serialise(self): self.serialise_obj.c1.l1.add(1) for signed in ["int", "uint"]: for size in [8, 16, 32, 64]: name = "%s%s" % (signed, size) setter = getattr(self.serialise_obj.c1.l1[1], "_set_%s" % name) setter(1) self.serialise_obj.c1.l1[1].restricted_integer = 6 self.serialise_obj.c1.l1[1].string = "bear" self.serialise_obj.c1.l1[1].restricted_string = "aardvark" self.serialise_obj.c1.l1[1].union = 16 self.serialise_obj.c1.l1[1].union_list.append(16) self.serialise_obj.c1.l1[1].union_list.append("chicken") self.serialise_obj.c1.t1.add(16) self.serialise_obj.c1.t1.add(32) self.serialise_obj.c1.l1[1].leafref = 16 self.serialise_obj.c1.l1[1].binary = bitarray("010101") self.serialise_obj.c1.l1[1].boolean = True self.serialise_obj.c1.l1[1].enumeration = "one" self.serialise_obj.c1.l1[1].identityref = "idone" self.serialise_obj.c1.l1[1].typedef_one = "test" self.serialise_obj.c1.l1[1].typedef_two = 8 self.serialise_obj.c1.l1[1].one_leaf = "hi" for i in range(1, 5): self.serialise_obj.c1.l1[1].ll.append(six.text_type(i)) self.serialise_obj.c1.l1[1].next_hop.append("DROP") self.serialise_obj.c1.l1[1].next_hop.append("192.0.2.1") self.serialise_obj.c1.l1[1].next_hop.append("fish") self.serialise_obj.c1.l1[1].typedef_decimal = Decimal("21.21") self.serialise_obj.c1.l1[1].range_decimal = Decimal("4.44443322") self.serialise_obj.c1.l1[1].typedef_decimalrange = Decimal("42.42") self.serialise_obj.c1.l1[1].decleaf = Decimal("42.4422") for i in range(1, 10): self.serialise_obj.c1.l2.add(i) pybind_json = json.loads(dumps(self.serialise_obj)) with open(os.path.join(os.path.dirname(__file__), "json", "expected-output.json"), "r") as fp: external_json = json.load(fp) self.assertEqual(pybind_json, external_json, "JSON did not match expected output.")
class JSONSerialiseTests(PyangBindTestCase): yang_files = ['json-serialise.yang'] pyang_flags = ['--use-xpathhelper'] def setUp(self): self.yang_helper = YANGPathHelper() self.serialise_obj = self.bindings.json_serialise(path_helper=self.yang_helper) def test_serialise_container(self): self.serialise_obj.two.string_test = "twenty-two" with open(os.path.join(os.path.dirname(__file__), "json", "container.json"), 'r') as fp: self.assertEqual( json.loads(dumps(self.yang_helper.get("/two")[0])), json.load(fp), "Invalid output returned when serialising a container." ) def test_full_serialise(self): self.serialise_obj.c1.l1.add(1) for signed in ["int", "uint"]: for size in [8, 16, 32, 64]: name = "%s%s" % (signed, size) setter = getattr(self.serialise_obj.c1.l1[1], "_set_%s" % name) setter(1) self.serialise_obj.c1.l1[1].restricted_integer = 6 self.serialise_obj.c1.l1[1].string = "bear" self.serialise_obj.c1.l1[1].restricted_string = "aardvark" self.serialise_obj.c1.l1[1].union = 16 self.serialise_obj.c1.l1[1].union_list.append(16) self.serialise_obj.c1.l1[1].union_list.append("chicken") self.serialise_obj.c1.t1.add(16) self.serialise_obj.c1.t1.add(32) self.serialise_obj.c1.l1[1].leafref = 16 self.serialise_obj.c1.l1[1].binary = bitarray("010101") self.serialise_obj.c1.l1[1].boolean = True self.serialise_obj.c1.l1[1].enumeration = "one" self.serialise_obj.c1.l1[1].identityref = "idone" self.serialise_obj.c1.l1[1].typedef_one = "test" self.serialise_obj.c1.l1[1].typedef_two = 8 self.serialise_obj.c1.l1[1].one_leaf = "hi" for i in range(1, 5): self.serialise_obj.c1.l1[1].ll.append(six.text_type(i)) self.serialise_obj.c1.l1[1].next_hop.append("DROP") self.serialise_obj.c1.l1[1].next_hop.append("192.0.2.1") self.serialise_obj.c1.l1[1].next_hop.append("fish") self.serialise_obj.c1.l1[1].typedef_decimal = Decimal("21.21") self.serialise_obj.c1.l1[1].range_decimal = Decimal("4.44443322") self.serialise_obj.c1.l1[1].typedef_decimalrange = Decimal("42.42") self.serialise_obj.c1.l1[1].decleaf = Decimal("42.4422") for i in range(1, 10): self.serialise_obj.c1.l2.add(i) pybind_json = json.loads(dumps(self.serialise_obj)) with open(os.path.join(os.path.dirname(__file__), "json", "expected-output.json"), 'r') as fp: external_json = json.load(fp) self.assertEqual(pybind_json, external_json, "JSON did not match expected output.")
def t1_add_retr_object_plain(tree=None): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() obj_one = TestObject("t1_ObjOneTest") tree.register(["obj_one"], obj_one) retr_obj = tree.get(["obj_one"]) assert len(retr_obj) == 1, ("retrieved path matched the wrong number " + "of objects (%d != 1)" % (len(retr_obj))) assert isinstance(retr_obj[0], TestObject), ("retrieved object was not " + "the correct class") assert retr_obj[0].name() == "t1_ObjOneTest", ( "retrieved object had an " + "invalid name specified (%s != t1_ObjOneTest)" % retr_obj.name()) if del_tree: del tree
def __init__(self, module_cfg): try: self._modcfg = yaml.load(open(module_cfg, 'r')) except IOError: raise PyNMSServerExampleException( "Configuration file did not exist") self._yph = YANGPathHelper() self.load_modules()
def t2_add_retr_object_with_attr(tree=None): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() for p in [["container"], ["container", "deeper"]]: tree.register(p, TestObject("container")) for q_style in ["'", '"', ""]: for i in range(0, 5): tree.register(p + ["foo[id=%s%d%s]" % ( q_style, i, q_style, )], TestObject("t2_ObjTest%d" % i)) for q_style in ["'", '"', ""]: for j in range(0, 5): retr_obj = tree.get("%s/foo[id=%s%d%s]" % ( "/" + "/".join(p), q_style, j, q_style, )) assert len(retr_obj) == 1, ( "retrieved the wrong number of " + "objects (%d != 1)" % len(retr_obj)) assert isinstance( retr_obj[0], TestObject), ("retrieved object " + "was not the correct class") assert retr_obj[0].name() == "t2_ObjTest%d" % j, \ ("retrieved object had an invalid name specified (%s != " + "t2_ObjTest%d, q_style=%s)" % (retr_obj.name(), j, q_style)) if del_tree: del tree
def t4_retr_obj_error(tree=False): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() retr = tree.get("/a/non-existant/path") assert len(retr) == 0, ("getting a non-existant path returned the wrong " + "number of objects (%d != 0)" % (len(retr))) passed = False try: tree.register("an-invalid-path-name", TestObject("invalid")) except XPathError: passed = True assert passed is True, ("setting an invalid path did not throw " + "an XPathError")
def __init__(self, data={}): self._utils = Utils() self._proceedings = Proceedings() self._data = data self._yang_ph = YANGPathHelper() self._yang = vnf_bd.vnf_bd(path_helper=self._yang_ph) self._protobuf = VnfBd() self._inputs = {} self._environment = {}
def setUp(self): self.path_helper = YANGPathHelper() self.yang_obj = self.bindings.current_tc03( path_helper=self.path_helper) for i in [(1, 2), (3, 4), (5, 6)]: self.yang_obj.src_list.add("%s %s" % i) self.yang_obj.referencing_list.add(1) self.yang_obj.referencing_list[1].source_val = "1" self.yang_obj.referencing_list[1].reference = "2"
def __init__(self, data=None): self._utils = Utils() self._data = data self._yang_ph = YANGPathHelper() self._yang = vnf_br.vnf_br(path_helper=self._yang_ph) self._protobuf = VnfBr() self._inputs = Inputs() self._outputs = {} self._output_ids = 1
def t3_add_retr_object_hierarchy(tree=False): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() path = [] obj = {} for i in range(0, 10): path += ["node%d" % i] obj[i] = TestObject(i) tree.register(path, obj[i]) path = "" for j in range(0, 10): path += "/node%d" % j retr_obj = tree.get(path) assert len(retr_obj) == 1, \ ("incorrect number of objects retrieved for %s (%d != 1)" % (path, len(retr_obj))) assert retr_obj[0].name() == j, ("retrieved object did not " + "have a valid name (%s != %s)" % (j, retr_obj.name()))
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "k", ["keepfiles"]) except getopt.GetoptError as e: print(str(e)) sys.exit(127) k = False for o, a in opts: if o in ["-k", "--keepfiles"]: k = True pythonpath = os.environ.get("PATH_TO_PYBIND_TEST_PYTHON") if \ os.environ.get('PATH_TO_PYBIND_TEST_PYTHON') is not None \ else sys.executable pyangpath = os.environ.get('PYANGPATH') if os.environ.get('PYANGPATH') \ is not None else False pyangbindpath = os.environ.get('PYANGBINDPATH') if \ os.environ.get('PYANGBINDPATH') is not None else False assert pyangpath is not False, "could not find path to pyang" assert pyangbindpath is not False, "could not resolve pyangbind directory" this_dir = os.path.dirname(os.path.realpath(__file__)) cmd = "%s " % pythonpath cmd += "%s --plugindir %s/pyangbind/plugin" % (pyangpath, pyangbindpath) cmd += " -f pybind -o %s/bindings.py" % this_dir cmd += " -p %s" % this_dir cmd += " --use-xpathhelper" cmd += " %s/%s.yang" % (this_dir, TESTNAME) print(cmd) os.system(cmd) from bindings import list_tc01 as ytest yhelper = YANGPathHelper() yobj = ytest(path_helper=yhelper) t1_leaflist(yobj, yhelper) t2_list(yobj, yhelper) t3_leaflist_remove(yobj, yhelper) t4_list_remove(yobj, yhelper) t5_typedef_leaflist_add_del(yobj, yhelper) t6_typedef_list_add(yobj, yhelper) t7_leaflist_of_leafrefs(yobj, yhelper) t8_standalone_leaflist_check(yobj, yhelper) t9_get_list(yobj, yhelper) if not k: os.system("/bin/rm %s/bindings.py" % this_dir) os.system("/bin/rm %s/bindings.pyc" % this_dir)
def test_002_handle_get_one_path(self): server_ph = YANGPathHelper() s = simple_device(path_helper=server_ph) s.system.config.hostname = "rtr0.lhr.uk" s.system.config.domain_name = "test.jiveip.net" get_msg = PyNMSClientGRPCMethods.generate_get_message(["/system"], 0) ret_msg = PyNMSServerGRPCMethods.service_get_request( get_msg, server_ph) self.assertEqual(ret_msg.request_id, 0) self.assertEqual(ret_msg.response_code, 0) self.assertEqual(pynms_rpc_pb2.RPCResponse.Name(ret_msg.response_code), 'OK') self.assertEqual(len(ret_msg.response), 1) self.assertEqual(ret_msg.response[0].path, "/system") err = None try: json_returned = json.loads(ret_msg.response[0].value) except Exception as e: err = e self.assertIsNone(err) self.assertEqual( json_returned, { u'simple-device:ntp': { u'state': { u'enabled': False }, u'config': { u'enabled': False } }, u'simple-device:config': { u'domain-name': u'test.jiveip.net', u'hostname': u'rtr0.lhr.uk' }, u'simple-device:state': { u'domain-name': u'', u'hostname': u'' } }) del server_ph
def parse(self, data=None): data = data if data else self._data self._yang_ph = YANGPathHelper() yang_model = self._utils.parse(data, vnf_br, "vnf-br", path_helper=self._yang_ph) if yang_model: logger.info(f"Parsing YANG model data successful") self._yang = yang_model self._data = data return True logger.info(f"Could not parse YANG model data") return False
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "k", ["keepfiles"]) except getopt.GetoptError as e: print str(e) sys.exit(127) k = False for o, a in opts: if o in ["-k", "--keepfiles"]: k = True pythonpath = os.environ.get("PATH_TO_PYBIND_TEST_PYTHON") if \ os.environ.get('PATH_TO_PYBIND_TEST_PYTHON') is not None \ else sys.executable pyangpath = os.environ.get('PYANGPATH') if \ os.environ.get('PYANGPATH') is not None else False pyangbindpath = os.environ.get('PYANGBINDPATH') if \ os.environ.get('PYANGBINDPATH') is not None else False assert pyangpath is not False, "could not find path to pyang" assert pyangbindpath is not False, "could not resolve pyangbind directory" this_dir = os.path.dirname(os.path.realpath(__file__)) cmd = "%s " % pythonpath cmd += "%s --plugindir %s/pyangbind/plugin" % (pyangpath, pyangbindpath) cmd += " -f pybind " cmd += " --split-class-dir=%s/bindings" % this_dir cmd += " -p %s" % this_dir cmd += " --use-xpathhelper --build-rpc" cmd += " %s/%s.yang" % (this_dir, TESTNAME) os.system(cmd) from pyangbind.lib.xpathhelper import YANGPathHelper ph = YANGPathHelper() import_error = None set_argument_error = None try: from bindings.rpc_rpc import check ch = check.check(path_helper=ph) ch.input.argument = "test" except ImportError, m: import_error = m
def t1_listkey(yobj, tree=False): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() for x in range(0, 100): yobj.container.t1a.add("x%s" % x) for x in range(0, 100): assert yobj.container.t1a["x%s" % x].t1c.t1d == "x%s" % x, \ "list key was not set correctly when acting as a pointer " + \ "(%s != 'test')" % (yobj.container.t1a["x%s" % x].t1c.t1d) assert str(yobj.container.t1a["x%s" % x].t1b) == "x%s" % x, \ "list key pointer was not read correctly (value is %s)" % \ yobj.container.t1a["x%s" % x].t1b if del_tree: del tree
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "k", ["keepfiles"]) except getopt.GetoptError as e: print(str(e)) sys.exit(127) k = False for o, a in opts: if o in ["-k", "--keepfiles"]: k = True pythonpath = os.environ.get("PATH_TO_PYBIND_TEST_PYTHON") if \ os.environ.get('PATH_TO_PYBIND_TEST_PYTHON') is not None \ else sys.executable pyangpath = os.environ.get('PYANGPATH') if os.environ.get('PYANGPATH') \ is not None else False pyangbindpath = os.environ.get('PYANGBINDPATH') if \ os.environ.get('PYANGBINDPATH') is not None else False assert pyangpath is not False, "could not find path to pyang" assert pyangbindpath is not False, "could not resolve pyangbind directory" this_dir = os.path.dirname(os.path.realpath(__file__)) cmd = "%s " % pythonpath cmd += "%s --plugindir %s/pyangbind/plugin" % (pyangpath, pyangbindpath) cmd += " -f pybind -o %s/bindings.py" % this_dir cmd += " -p %s" % this_dir cmd += " --use-xpathhelper" cmd += " %s/%s.yang" % (this_dir, TESTNAME) os.system(cmd) from bindings import current_tc03 yhelper = YANGPathHelper() yobj = current_tc03(path_helper=yhelper) t1_currentref(yobj, tree=yhelper) if not k: os.system("/bin/rm %s/bindings.py" % this_dir) os.system("/bin/rm %s/bindings.pyc" % this_dir)
def test_004_handle_one_set_path(self): server_ph = YANGPathHelper() s = simple_device(path_helper=server_ph) c = simple_device() c.system.config.hostname = "rtr0.lhr.uk" c.system.config.domain_name = "test.jiveip.net" set_msg = PyNMSClientGRPCMethods.generate_set_message( [PyNMSConfigOperation(c.system)]) ret_msg = PyNMSServerGRPCMethods.service_set_request( set_msg, server_ph) self.assertEqual(ret_msg.request_id, 0) self.assertEqual(ret_msg.response_code, 0) self.assertEqual(pynms_rpc_pb2.RPCResponse.Name(ret_msg.response_code), 'OK') self.assertEqual(ret_msg.message, "") self.assertEqual(s.system.config.hostname, "rtr0.lhr.uk") self.assertEqual(s.system.config.domain_name, "test.jiveip.net") del server_ph
def t2_add_retr_object_with_attr(tree=False): del_tree = False if not tree: del_tree = True tree = YANGPathHelper() for p in [["container"], ["container", "deeper"]]: tree.register(p, TestObject("container")) for q_style in ["'", '"', ""]: for i in range(0, 5): tree.register(p + ["foo[id=%s%d%s]" % (q_style, i, q_style,)], TestObject("t2_ObjTest%d" % i)) for q_style in ["'", '"', ""]: for j in range(0, 5): retr_obj = tree.get("%s/foo[id=%s%d%s]" % ("/" + "/".join(p), q_style, j, q_style,)) assert len(retr_obj) == 1, ("retrieved the wrong number of " + "objects (%d != 1)" % len(retr_obj)) assert isinstance(retr_obj[0], TestObject), ("retrieved object " + "was not the correct class") assert retr_obj[0].name() == "t2_ObjTest%d" % j, \ ("retrieved object had an invalid name specified (%s != " + "t2_ObjTest%d, q_style=%s)" % (retr_obj.name(), j, q_style)) if del_tree: del tree
class PathHelperBaseTests(unittest.TestCase): def setUp(self): self.tree = YANGPathHelper() def test_get_returns_same_number_of_objects_as_registered(self): obj = TestObject('testobj') self.tree.register(['obj_one'], obj) self.assertEqual(len(self.tree.get(['obj_one'])), 1) def test_get_returns_objects_of_same_class_as_registered(self): obj = TestObject('testobj') self.tree.register(['obj_one'], obj) self.assertIsInstance(self.tree.get(['obj_one'])[0], TestObject) def test_get_returns_objects_with_same_attributes_as_registered(self): obj = TestObject('testobj') self.tree.register(['obj_one'], obj) self.assertEqual(self.tree.get(['obj_one'])[0].name(), 'testobj') def test_get_non_existent_path_returns_nothing(self): self.assertEqual(len(self.tree.get('/a/non-existent/path')), 0) def test_register_invalid_path_raises_exception(self): with self.assertRaises(XPathError): self.tree.register('an-invalid-path-name', TestObject('invalid')) def test_retrieve_object_at_bottom_of_hierarchy_returns_single_object(self): self.tree.register(['node0'], TestObject(0)) self.tree.register(['node0', 'node1'], TestObject(1)) self.tree.register(['node0', 'node1', 'node2'], TestObject(2)) self.assertEqual(len(self.tree.get('/node0/node1/node2')), 1) def test_retrieve_object_at_bottom_of_hierarchy_has_proper_name(self): self.tree.register(['node0'], TestObject(0)) self.tree.register(['node0', 'node1'], TestObject(1)) self.tree.register(['node0', 'node1', 'node2'], TestObject(2)) self.assertEqual(self.tree.get('/node0/node1/node2')[0].name(), 2) def test_register_object_with_attribute(self): self.tree.register(['container'], TestObject('container')) allowed = True try: self.tree.register(['container', 'foo[id=0]'], TestObject('bar')) except Exception: allowed = False self.assertTrue(allowed) def test_retrieve_object_by_attribute_returns_single_object(self): self.tree.register(['container'], TestObject('container')) self.tree.register(['container', 'foo[id=0]'], TestObject('bar0')) self.tree.register(['container', 'foo[id=1]'], TestObject('bar1')) self.assertEqual(len(self.tree.get('/container/foo[id=0]')), 1) def test_get_object_by_attribute_returns_object_of_same_class(self): self.tree.register(['container'], TestObject('container')) self.tree.register(['container', 'foo[id=0]'], TestObject('bar0')) self.assertIsInstance(self.tree.get('/container/foo[id=0]')[0], TestObject) def test_register_object_with_attribute_various_quoting_styles(self): self.tree.register(['container'], TestObject('container')) for style in ['"', "'", '']: with self.subTest(style=style): allowed = True try: self.tree.register(['container', 'foo[id={0}42{0}]'.format(style)], TestObject(42)) except Exception: allowed = False self.assertTrue(allowed) def test_get_object_with_attribute_various_quoting_styles(self): self.tree.register(['container'], TestObject('container')) self.tree.register(['container', 'foo[id=42]'], TestObject('bar42')) for style in ['"', "'", '']: with self.subTest(style=style): obj = self.tree.get('/container/foo[id={0}42{0}]'.format(style))[0] self.assertEqual(obj.name(), 'bar42')
class XPathRootTests(PyangBindTestCase): yang_files = ['root-tc04-a.yang', 'root-tc04-b.yang'] pyang_flags = ['--use-extmethods', '--use-xpathhelper'] def setUp(self): self.path_helper = YANGPathHelper() self.instance_a = self.bindings.root_tc04_a(path_helper=self.path_helper) self.instance_b = self.bindings.root_tc04_b(path_helper=self.path_helper) def test_001_check_containers(self): self.assertIsNot(getattr(self.instance_a, safe_name("root-tc04-a"), None), None) self.assertIsNot(getattr(self.instance_b, safe_name("root-tc04-b"), None), None) def test_002_base_gets(self): # each of these raise exceptions so will cause test case failures self.path_helper.get_unique("/") self.path_helper.get_unique("/root-tc04-a") self.path_helper.get_unique("/root-tc04-b") def test_003_base_sets(self): a = self.path_helper.get_unique("/root-tc04-a") a.a = "little-cottonwood" self.assertEqual(self.instance_a.root_tc04_a.a, "little-cottonwood") b = self.path_helper.get_unique("/root-tc04-b") b.b = "big-cottonwood" self.assertEqual(self.instance_b.root_tc04_b.b, "big-cottonwood") def test_004_serialise(self): self.instance_a.root_tc04_a.a = "emigration" self.instance_b.root_tc04_b.b = "alpine-fork" with open(os.path.join(os.path.dirname(__file__), "json", "04-serialise.json")) as fp: expected_json = json.load(fp) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"))) self.assertEqual(v, expected_json) with open(os.path.join(os.path.dirname(__file__), "json", "04b-ietf-serialise.json")) as fp: expected_ietf_json = json.load(fp) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"), mode="ietf")) self.assertEqual(v, expected_ietf_json) def test_005_deserialise(self): root = self.path_helper.get_unique("/") with open(os.path.join(os.path.dirname(__file__), "json", "05-deserialise.json"), 'r') as fp: pybindJSONDecoder.load_json(json.load(fp), None, None, obj=root) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"))) with open(os.path.join(os.path.dirname(__file__), "json", "05-deserialise.json"), 'r') as fp: x = json.load(fp) self.assertEqual(v, x) def test_006_ietf_deserialise(self): root = self.path_helper.get_unique("/") with open(os.path.join(os.path.dirname(__file__), "json", "06-deserialise-ietf.json"), 'r') as fp: pybindJSONDecoder.load_ietf_json(json.load(fp), None, None, obj=root) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"), mode="ietf")) with open(os.path.join(os.path.dirname(__file__), "json", "06-deserialise-ietf.json"), 'r') as fp: x = json.load(fp) self.assertEqual(v, x)
def setUp(self): self.path_helper = YANGPathHelper()
def setUp(self): self.yang_helper = YANGPathHelper()
class PyangbindXpathRootTC04(unittest.TestCase): def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) err = None try: globals()["bindings"] = importlib.import_module("bindings") except ImportError as e: err = e self.assertIs(err, None) self.path_helper = YANGPathHelper() self.instance_a = bindings.root_tc04_a(path_helper=self.path_helper) self.instance_b = bindings.root_tc04_b(path_helper=self.path_helper) def test_001_check_containers(self): self.assertIsNot(getattr(self.instance_a, safe_name("root-tc04-a"), None), None) self.assertIsNot(getattr(self.instance_b, safe_name("root-tc04-b"), None), None) def test_002_base_gets(self): # each of these raise exceptions so will cause test case failures self.path_helper.get_unique("/") self.path_helper.get_unique("/root-tc04-a") self.path_helper.get_unique("/root-tc04-b") def test_003_base_sets(self): a = self.path_helper.get_unique("/root-tc04-a") a.a = "little-cottonwood" self.assertEqual(self.instance_a.root_tc04_a.a, "little-cottonwood") b = self.path_helper.get_unique("/root-tc04-b") b.b = "big-cottonwood" self.assertEqual(self.instance_b.root_tc04_b.b, "big-cottonwood") def test_004_serialise(self): self.instance_a.root_tc04_a.a = "emigration" self.instance_b.root_tc04_b.b = "alpine-fork" expected_json = json.load(open(os.path.join(this_dir, "json", "04-serialise.json"))) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"))) self.assertEqual(v,expected_json) expected_ietf_json = json.load(open(os.path.join(this_dir, "json", "04b-ietf-serialise.json"))) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"), mode="ietf")) self.assertEqual(v, expected_ietf_json) def test_005_deserialise(self): root = self.path_helper.get_unique("/") fh = open(os.path.join(this_dir, "json", "05-deserialise.json"), 'r') pybindJSONDecoder.load_json(json.load(fh), None, None, obj=root) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"))) x = json.load(open(os.path.join(this_dir, "json", "05-deserialise.json"), 'r')) self.assertEqual(v, x) def test_006_ietf_deserialise(self): root = self.path_helper.get_unique("/") fh = open(os.path.join(this_dir, "json", "06-deserialise-ietf.json"), 'r') pybindJSONDecoder.load_ietf_json(json.load(fh), None, None, obj=root) v = json.loads(pbJ.dumps(self.path_helper.get_unique("/"), mode="ietf")) x = json.load(open(os.path.join(this_dir, "json", "06-deserialise-ietf.json"), 'r')) self.assertEqual(v, x)
def setUp(self): self.path_helper = YANGPathHelper() self.instance_a = self.bindings.root_tc04_a(path_helper=self.path_helper) self.instance_b = self.bindings.root_tc04_b(path_helper=self.path_helper)
class RPCTests(PyangBindTestCase): yang_files = ["rpc.yang"] split_class_dir = True pyang_flags = ["--use-xpathhelper", "--build-rpc"] def setUp(self): self.path_helper = YANGPathHelper() def test_set_input_argument(self): from bindings.rpc_rpc.check import check instance = check(path_helper=self.path_helper) allowed = True try: instance.input.argument = "test" except ValueError: allowed = False self.assertTrue(allowed) def test_set_output_arguments(self): from bindings.rpc_rpc.check_two import output instance = output.output(path_helper=self.path_helper) allowed = True try: instance.arg_one = 10 instance.arg_two = 20 except ValueError: allowed = False self.assertTrue(allowed) def test_set_input_arguments_inside_container(self): from bindings.rpc_rpc.check_three import check_three instance = check_three(path_helper=self.path_helper) allowed = True try: instance.input.arguments.arg_one = "test string" instance.input.arguments.arg_two = "another test string" except ValueError: allowed = False self.assertTrue(allowed) def test_set_output_arguments_with_multiple_containers(self): from bindings.rpc_rpc.check_four import check_four instance = check_four(path_helper=self.path_helper) allowed = True try: instance.output.arguments.arg_one = "test string" instance.output.arguments_two.arg_two = "another test string" except ValueError: allowed = False self.assertTrue(allowed) def set_input_and_output_arguments_on_a_single_rpc_check(self): from bindings.rpc_rpc.check_five import check_five instance = check_five(path_helper=self.path_helper) allowed = True try: instance.input.arguments.arg_one = "test string" instance.output.return_values.return_val = 10 except ValueError: allowed = False self.assertTrue(allowed) def test_rpc_attributes_do_not_register_in_path_helper(self): from bindings.rpc_rpc.check import check instance = check(path_helper=self.path_helper) instance.input.argument = "test string" self.assertEqual(dict(self.path_helper.get_unique("/")), {}) def test_set_input_argument_to_valid_leafref(self): from bindings import rpc from bindings.rpc_rpc.check_six import check_six base_instance = rpc(path_helper=self.path_helper) instance = check_six(path_helper=self.path_helper) base_instance.test.reference_target.append("six") allowed = True try: instance.input.argument = "six" except ValueError: allowed = False self.assertTrue(allowed) def test_set_input_argument_to_invalid_leafref(self): from bindings import rpc from bindings.rpc_rpc.check_six import check_six base_instance = rpc(path_helper=self.path_helper) instance = check_six(path_helper=self.path_helper) base_instance.test.reference_target.append("six") with self.assertRaises(ValueError): instance.input.argument = "fish"
def setUp(self): self.yang_helper = YANGPathHelper() self.serialise_obj = self.bindings.json_serialise(path_helper=self.yang_helper)
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "k", ["keepfiles"]) except getopt.GetoptError as e: print(str(e)) sys.exit(127) k = False for o, a in opts: if o in ["-k", "--keepfiles"]: k = True pythonpath = os.environ.get("PATH_TO_PYBIND_TEST_PYTHON") if \ os.environ.get('PATH_TO_PYBIND_TEST_PYTHON') is not None \ else sys.executable pyangpath = os.environ.get('PYANGPATH') if \ os.environ.get('PYANGPATH') is not None else False pyangbindpath = os.environ.get('PYANGBINDPATH') if \ os.environ.get('PYANGBINDPATH') is not None else False assert pyangpath is not False, "could not find path to pyang" assert pyangbindpath is not False, "could not resolve pyangbind directory" OC = "https://raw.githubusercontent.com/openconfig/" + \ "public/master/release/models/" RFC = "https://raw.githubusercontent.com/robshakir/" + \ "yang/master/standard/ietf/RFC/" FETCH_FILES = [ (OC + "bgp/openconfig-bgp-common-multiprotocol.yang", "openconfig"), (OC + "bgp/openconfig-bgp-common-structure.yang", "openconfig"), (OC + "bgp/openconfig-bgp-common.yang", "openconfig"), (OC + "bgp/openconfig-bgp-global.yang", "openconfig"), (OC + "bgp/openconfig-bgp-neighbor.yang", "openconfig"), (OC + "bgp/openconfig-bgp-peer-group.yang", "openconfig"), (OC + "bgp/openconfig-bgp-policy.yang", "openconfig"), (OC + "bgp/openconfig-bgp-errors.yang", "openconfig"), (OC + "types/openconfig-inet-types.yang", "include"), (OC + "types/openconfig-yang-types.yang", "include"), (OC + "bgp/openconfig-bgp-types.yang", "include"), (OC + "bgp/openconfig-bgp.yang", "openconfig"), (OC + "policy/openconfig-routing-policy.yang", "openconfig"), (OC + "policy/openconfig-policy-types.yang", "include"), (OC + "openconfig-extensions.yang", "include"), (OC + "types/openconfig-types.yang", "include"), (OC + "interfaces/openconfig-interfaces.yang", "openconfig"), (OC + "types/openconfig-yang-types.yang", "openconfig"), (OC + "types/openconfig-inet-types.yang", "openconfig"), (RFC + "ietf-inet-types.yang", "include"), (RFC + "ietf-yang-types.yang", "include"), (RFC + "ietf-interfaces.yang", "include") ] this_dir = os.path.dirname(os.path.realpath(__file__)) del_dirs = [] for fn in FETCH_FILES: wrdir = os.path.join(this_dir, fn[1]) if not os.path.exists(wrdir): os.mkdir(wrdir) if wrdir not in del_dirs: del_dirs.append(wrdir) wrpath = os.path.join(this_dir, fn[1], fn[0].split("/")[-1]) if not os.path.exists(wrpath): got = False count = 0 for i in range(0, 4): response = requests.get(fn[0]) if response.status_code != 200: time.sleep(2) else: got = True f = open(wrpath, 'w') f.write(response.text) f.close() break assert got is True, "Could not get file %s from GitHub (response: %s)" \ % (response.status_code, fn[0]) files_str = " ".join([ os.path.join(this_dir, "openconfig", i) for i in os.listdir(os.path.join(this_dir, "openconfig")) ]) cmd = "%s " % pythonpath cmd += "%s --plugindir %s/pyangbind/plugin" % (pyangpath, pyangbindpath) cmd += " -f pybind --split-class-dir %s/ocbind" % this_dir cmd += " -p %s" % this_dir cmd += " -p %s" % os.path.join(this_dir, "include") cmd += " %s" % os.path.join(this_dir, "openconfig", "openconfig-bgp.yang") # NB: use-xpathhelper is NOT specified here, so we don't try and do anything # with leafrefs os.system(cmd) import ocbind yh = YANGPathHelper() json_dir = os.path.join(this_dir, "json") jbgp_global_ex = json.load( open(os.path.join(json_dir, "bgp-global-ex.json"), 'r')) ljs = pybindJSONDecoder.load_ietf_json(jbgp_global_ex["configuration"], ocbind, "openconfig_bgp", path_helper=yh) expected_ljs = \ { "bgp": { "global": { "confederation": { "config": { "identifier": 65517, "member-as": [ 65518, 65519, 65520 ] } } } } } assert ljs.get(filter=True) == expected_ljs, \ "Invalid JSON loaded for global config" jbgp_neigh_list = json.load( open(os.path.join(json_dir, "bgp-neighbor-list-ex.json"), 'r')) ljs = pybindJSONDecoder.load_ietf_json(jbgp_neigh_list["configuration"], ocbind, "openconfig_bgp", path_helper=yh) expected_ljs = \ { "bgp": { "neighbors": { "neighbor": { "13.13.13.13": { "neighbor-address": "13.13.13.13", "config": { "peer-group": "g1" } }, "12.12.12.12": { "neighbor-address": "12.12.12.12", "config": { "peer-group": "g1" } } } } } } assert ljs.get(filter=True) == expected_ljs, \ "Invalid JSON returned when loading neighbor list" jbgp_gr = json.load(open(os.path.join(json_dir, "bgp-gr-ex.json"), 'r')) ljs = pybindJSONDecoder.load_ietf_json(jbgp_gr["configuration"], ocbind, "openconfig_bgp", path_helper=yh) expected_ljs = \ { "bgp": { "neighbors": { "neighbor": { "12.12.12.12": { "config": { "peer-group": "g1" }, "neighbor-address": "12.12.12.12" }, "13.13.13.13": { "neighbor-address": "13.13.13.13", "config": { "peer-group": "g2" } } } } } } assert ljs.get(filter=True) == expected_ljs, \ "Graceful restart example was not loaded correctly" assert ljs.bgp.neighbors.neighbor[u"12.12.12.12"]._metadata == \ {u"inactive": True}, \ "Metadata for GR example was not loaded correctly" jbgp_deactivated = json.load( open(os.path.join(json_dir, "bgp-deactivated-config-ex.json"), 'r')) ljs = pybindJSONDecoder.load_ietf_json(jbgp_deactivated["configuration"], ocbind, "openconfig_bgp", path_helper=yh) expected_ljs = \ { "bgp": { "global": { "config": { "router-id": "10.10.10.10" } } } } assert ljs.get(filter=True) == expected_ljs, \ "Router ID configuration example not loaded correctly" assert ljs.bgp.global_.config.router_id._metadata["inactive"] == True, \ "Metadata for router-id element not set correctly" if not k: del_dirs.append(os.path.join(this_dir, "ocbind")) for dirname in del_dirs: for root, dirs, files in os.walk(os.path.join(dirname), topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name)) os.rmdir(dirname)
class XPathListLeaflistTests(PyangBindTestCase): yang_files = ["list-tc01.yang"] pyang_flags = ["--use-xpathhelper"] def setUp(self): self.path_helper = YANGPathHelper() self.instance = self.bindings.list_tc01(path_helper=self.path_helper) def test_leaflist_leafref_with_require_instance_true(self): for fish in ["mackerel", "trout", "haddock", "flounder"]: self.instance.container.t1.append(fish) for (fish, valid) in [("mackerel", True), ("haddock", True), ("minnow", False)]: with self.subTest(fish=fish, valid=valid): allowed = True try: self.instance.reference.t1_ptr = fish except ValueError: allowed = False self.assertEqual(valid, allowed) def test_leaflist_leafref_with_require_instance_false(self): for fish in ["mackerel", "trout", "haddock", "flounder"]: self.instance.container.t1.append(fish) for (fish, exists) in [("flounder", True), ("minnow", False)]: with self.subTest(fish=fish, exists=exists): allowed = True try: self.instance.reference.t1_ptr_noexist = fish except ValueError: allowed = False self.assertTrue(allowed) def test_list_leafref_with_require_instance_true(self): for animal in ["kangaroo", "wallaby", "koala", "dingo"]: self.instance.container.t2.add(animal) for (animal, valid) in [("kangaroo", True), ("koala", True), ("wombat", False)]: with self.subTest(animal=animal, valid=valid): allowed = True try: self.instance.reference.t2_ptr = animal except ValueError: allowed = False self.assertEqual(valid, allowed) def test_get_leaflist_with_xpath_helper_returns_single_element(self): for beer in ["oatmeal-stout", "amber-ale", "pale-ale", "pils", "ipa", "session-ipa"]: self.instance.container.t3.append(beer) self.assertEqual(len(self.path_helper.get("/container/t3")), 1) def test_find_elements_of_leaflist(self): for beer in ["oatmeal-stout", "amber-ale", "pale-ale", "pils", "ipa", "session-ipa"]: self.instance.container.t3.append(beer) leaflist = self.path_helper.get("/container/t3")[0] for (beer, valid) in [("session-ipa", True), ("amber-ale", True), ("moose-drool", False)]: with self.subTest(beer=beer, valid=valid): found = True try: leaflist.index(beer) except ValueError: found = False self.assertEqual(valid, found) def test_remove_elements_from_leaflist(self): for beer in ["oatmeal-stout", "amber-ale", "pale-ale", "pils", "ipa", "session-ipa"]: self.instance.container.t3.append(beer) for (beer, valid) in [("session-ipa", True), ("amber-ale", True), ("moose-drool", False)]: with self.subTest(beer=beer, valid=valid): removed = True try: self.instance.container.t3.remove(beer) except ValueError: removed = False self.assertEqual(removed, valid) def test_xpath_helper_gets_updated_leaflist_after_removing_items(self): for beer in ["oatmeal-stout", "amber-ale", "pale-ale", "pils", "ipa", "session-ipa"]: self.instance.container.t3.append(beer) retr = self.path_helper.get("/container/t3") # Retrieve before to get the old value for beer in ["session-ipa", "amber-ale"]: self.instance.container.t3.remove(beer) retr = self.path_helper.get("/container/t3") for beer in ["session-ipa", "amber-ale", "moose-drool"]: with self.subTest(beer=beer), self.assertRaises(ValueError): retr[0].index(beer) def test_get_list_item_with_xpath_helper_returns_single_element(self): for beer in ["steam", "liberty", "california-lager", "porter", "ipa", "foghorn"]: self.instance.container.t4.add(beer) for (beer, exists) in [("steam", 1), ("liberty", 1), ("pygmy-owl", 0)]: with self.subTest(beer=beer, exists=exists): retr = self.path_helper.get("/container/t4[keyval=%s]" % beer) self.assertEqual(len(retr), exists) def test_remove_elements_from_list(self): for beer in ["steam", "liberty", "california-lager", "porter", "ipa", "foghorn"]: self.instance.container.t4.add(beer) for (beer, valid) in [("steam", True), ("liberty", True), ("pygmy-owl", False)]: with self.subTest(beer=beer, valid=valid): removed = True try: self.instance.container.t4.delete(beer) except KeyError: removed = False self.assertEqual(removed, valid) def test_xpath_helper_gets_updated_list_after_removing_items(self): for beer in ["steam", "liberty", "california-lager", "porter", "ipa", "foghorn"]: self.instance.container.t4.add(beer) for beer in ["steam", "liberty", "pygmy-owl"]: with self.subTest(beer=beer): path = "/container/t4[keyval=%s]" retr = self.path_helper.get(path) try: self.instance.container.t4.delete(beer) except KeyError: pass retr = self.path_helper.get(path) self.assertEqual(len(retr), 0) def test_typedef_leaflist_with_require_instance_true(self): for city in ["quebec-city", "montreal", "laval", "gatineau"]: self.instance.container.t5.append(city) for (city, valid) in [("quebec-city", True), ("montreal", True), ("dallas", False)]: with self.subTest(city=city, valid=valid): allowed = True try: self.instance.reference.t5_ptr = city except ValueError: allowed = False self.assertEqual(valid, allowed) def test_typedef_list_with_require_instance_true(self): for beer in ["la-ciboire", "la-chipie", "la-joufflue", "la-matante"]: self.instance.container.t6.add(beer) for (beer, valid) in [("la-ciboire", True), ("la-matante", True), ("heiniken", False)]: with self.subTest(beer=beer, valid=valid): allowed = True try: self.instance.reference.t6_ptr = beer except ValueError: allowed = False self.assertEqual(valid, allowed) def test_leaflist_of_leafrefs_with_require_instance_true(self): for beer in ["snapshot", "ranger"]: self.instance.container.t7.append(beer) for (beer, valid) in [("snapshot", True), ("ranger", True), ("trout-slayer", False)]: with self.subTest(beer=beer, valid=valid): allowed = True try: self.instance.reference.t7_ptr.append(beer) except ValueError: allowed = False self.assertEqual(valid, allowed) def test_standalone_leaflist(self): self.instance.standalone.ll.append(1) retr = self.path_helper.get("/standalone/ll") self.assertEqual(retr[0][0], 1) def test_standlone_list(self): self.instance.standalone.l.add(1) retr = self.path_helper.get("/standalone/l") self.assertEqual(retr[0].x, 1) def test_standalone_ref(self): self.instance.standalone.l.add(1) self.instance.standalone.ref = 1 self.assertEqual(self.instance.standalone.ref._referenced_object, 1) def test_get_list_retrieves_correct_attribute(self): self.assertEqual(self.path_helper.get_list("/standalone/l")._yang_name, "l") def test_get_list_returns_correct_type(self): self.assertEqual(self.path_helper.get_list("/standalone/l")._is_container, "list")
def setUp(self): self.tree = YANGPathHelper()
def setUp(self): self.path_helper = YANGPathHelper() self.instance = self.bindings.list_tc01(path_helper=self.path_helper)
def setUp(self): self.path_helper = YANGPathHelper() self.instance = self.bindings.misc(path_helper=self.path_helper)
def main(): try: opts, args = getopt.getopt(sys.argv[1:], "k", ["keepfiles"]) except getopt.GetoptError as e: print str(e) sys.exit(127) k = False for o, a in opts: if o in ["-k", "--keepfiles"]: k = True pythonpath = os.environ.get("PATH_TO_PYBIND_TEST_PYTHON") if \ os.environ.get('PATH_TO_PYBIND_TEST_PYTHON') is not None \ else sys.executable pyangpath = os.environ.get('PYANGPATH') if \ os.environ.get('PYANGPATH') is not None else False pyangbindpath = os.environ.get('PYANGBINDPATH') if \ os.environ.get('PYANGBINDPATH') is not None else False assert pyangpath is not False, "could not find path to pyang" assert pyangbindpath is not False, "could not resolve pyangbind directory" this_dir = os.path.dirname(os.path.realpath(__file__)) cmd = "%s " % pythonpath cmd += "%s --plugindir %s/pyangbind/plugin" % (pyangpath, pyangbindpath) cmd += " -f pybind -o %s/bindings.py" % this_dir cmd += " -p %s" % this_dir cmd += " --use-xpathhelper" cmd += " %s/%s.yang" % (this_dir, TESTNAME) os.system(cmd) from bindings import json_serialise from bitarray import bitarray from pyangbind.lib.xpathhelper import YANGPathHelper y = YANGPathHelper() js = json_serialise(path_helper=y) js.c1.l1.add(1) for s in ["int", "uint"]: for l in [8, 16, 32, 64]: name = "%s%s" % (s, l) x = getattr(js.c1.l1[1], "_set_%s" % name) x(1) js.c1.l1[1].restricted_integer = 6 js.c1.l1[1].string = "bear" js.c1.l1[1].restricted_string = "aardvark" js.c1.l1[1].union = 16 js.c1.l1[1].union_list.append(16) js.c1.l1[1].union_list.append("chicken") js.c1.t1.add(16) js.c1.t1.add(32) js.c1.l1[1].leafref = 16 js.c1.l1[1].binary = bitarray("010101") js.c1.l1[1].boolean = True js.c1.l1[1].enumeration = "one" js.c1.l1[1].identityref = "idone" js.c1.l1[1].typedef_one = "test" js.c1.l1[1].typedef_two = 8 js.c1.l1[1].one_leaf = "hi" for i in range(1, 5): js.c1.l1[1].ll.append(unicode(i)) js.c1.l1[1].next_hop.append("DROP") js.c1.l1[1].next_hop.append("192.0.2.1") js.c1.l1[1].next_hop.append("fish") js.c1.l1[1].typedef_decimal = Decimal("21.21") js.c1.l1[1].range_decimal = Decimal("4.44443322") js.c1.l1[1].typedef_decimalrange = Decimal("42.42") js.c1.l1[1].decleaf = Decimal("42.4422") for i in range(1, 10): js.c1.l2.add(i) pybind_json = json.loads(dumps(js)) external_json = json.load(open(os.path.join(this_dir, "json", "expected-output.json"), 'r')) assert pybind_json == external_json, "JSON did not match the expected output" yph = YANGPathHelper() new_obj = json_serialise(path_helper=yph) new_obj.two.string_test = "twenty-two" assert json.loads(dumps(yph.get("/two")[0])) == \ json.load(open(os.path.join(this_dir, "json", "container.json"), 'r')), \ "Invalid output returned when serialising a container" if not k: os.system("/bin/rm %s/bindings.py" % this_dir) os.system("/bin/rm %s/bindings.pyc" % this_dir)