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