class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(
"127.0.0.1",
"admin",
"admin",
12022,
)
self.crud = CRUDService()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def test_delete_on_list_with_identitykey(self):
a1 = Runner.OneList.IdentityList()
a1.config.id = ChildIdentity()
a1.id_ref = a1.config.id
self.crud.create(self.ncc, a1)
k = Runner.OneList.IdentityList()
k.config.id = ChildIdentity()
k.id_ref = k.config.id
k.yfilter = YFilter.delete
self.crud.update(self.ncc, k)
runner_read = self.crud.read(self.ncc, Runner())
self.assertIsNone(runner_read)
def test_iden_list(self):
# CREATE
il = Runner.OneList.IdentityList()
il.config.id = ChildIdentity()
il.id_ref = ChildIdentity()
self.crud.create(self.ncc, il)
# READ & VALIDATE
runner_filter = Runner.OneList()
read_one = self.crud.read(self.ncc, runner_filter)
self.assertIsNotNone(read_one)
read_il = read_one.identity_list.get(ChildIdentity().to_string())
self.assertIsNotNone(read_il)
read_il.parent = None
self.assertEqual(read_il, il)
# DELETE & VALIDATE
self.crud.delete(self.ncc, il)
runner_read = self.crud.read(self.ncc, Runner())
self.assertIsNone(runner_read)
def config_bgp_ipv4(yang_repo="",
address="",
grpc_port="",
username="",
password="",
crud_op="add",
bgp={}):
repository = Repository(yang_repo)
provider = gNMIServiceProvider(repo=repository,
address=address,
port=int(grpc_port),
username=username,
password=password)
gnmi_service = gNMIService()
crud = CRUDService()
ni = oc_ni.NetworkInstances.NetworkInstance()
if "vrf" in list(bgp.keys()):
ni.name = bgp["vrf"]
else:
print("Vrf for network Instance not specified")
sys.exit(1)
protocol = ni.protocols.Protocol()
protocol.identifier = oc_policy_types.BGP()
protocol.name = "default"
protocol.config.identifier = oc_policy_types.BGP()
protocol.config.name = "default"
if "as" in list(bgp.keys()):
protocol.bgp.global_.config.as_ = int(bgp["as"])
else:
print("AS for BGP instance not specified")
sys.exit(1)
# Fill out your BGP object properly using the Openconfig Yang Model
# You will need to bring up the IBGP neighbor between rtr1 and rtr4
ni.protocols.protocol.append(protocol)
if crud_op == "add":
response = crud.create(provider, ni)
elif crud_op == "delete":
response = crud.delete(provider, ni)
elif crud_op is "update":
response = crud.update(provider, ni)
else:
print(
"Invalid operation requested, allowed values = add, update, delete"
)
return False
return response
def run_test(provider):
root = provider.get_session().get_root_schema()
crud = CRUDService()
"""Create interface configuration"""
ifc = ifmgr.InterfaceConfigurations.InterfaceConfiguration()
ifc.active = 'act'
ifc.interface_name = 'Loopback10'
ifc.description = 'Test interface'
ifc.interface_virtual = Empty()
ip_address = ifmgr.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network.Addresses.Primary(
)
ip_address.address = '172.16.255.1'
ip_address.netmask = '255.255.255.255'
ifc.ipv4_network.addresses.primary = ip_address
ifc_create = ifmgr.InterfaceConfigurations()
ifc_create.interface_configuration.append(ifc)
reply = crud.update(provider, ifc_create)
"""Read interface operational data"""
ifc_oper_filter = ifoper.InterfaceProperties()
dn = ifoper.InterfaceProperties.DataNodes.DataNode()
dn.data_node_name = '"0/RP0/CPU0"'
ifc_oper_filter.data_nodes.data_node.append(dn)
lview = ifoper.InterfaceProperties.DataNodes.DataNode.Locationviews.Locationview(
)
lview.locationview_name = '"0/RP0/CPU0"'
dn.locationviews.locationview.append(lview)
ifc = ifoper.InterfaceProperties.DataNodes.DataNode.Locationviews.Locationview.Interfaces.Interface(
)
ifc.interface_name = '"Loopback10"'
ifc.state = YFilter.read
lview.interfaces.interface.append(ifc)
ifc_oper_data = crud.read(provider, ifc_oper_filter)
if ifc_oper_data is not None:
print('INTERFACE OPERATIONAL DATA:')
print_entity(ifc_oper_data, root)
def config_bgp_ipv4(yang_repo="",
address="",
grpc_port="",
username="",
password="",
crud_op="add",
bgp={}):
repository = Repository(yang_repo)
provider = gNMIServiceProvider(repo=repository,
address=address,
port=int(grpc_port),
username=username,
password=password)
gnmi_service = gNMIService()
crud = CRUDService()
ni = oc_ni.NetworkInstances.NetworkInstance()
if "vrf" in list(bgp.keys()):
ni.name = bgp["vrf"]
else:
print("Vrf for network Instance not specified")
sys.exit(1)
protocol = ni.protocols.Protocol()
protocol.identifier = oc_policy_types.BGP()
protocol.name = "default"
protocol.config.identifier = oc_policy_types.BGP()
protocol.config.name = "default"
if "as" in list(bgp.keys()):
protocol.bgp.global_.config.as_ = int(bgp["as"])
else:
print("AS for BGP instance not specified")
sys.exit(1)
if "router_id" in list(bgp.keys()):
protocol.bgp.global_.config.router_id = bgp["router_id"]
afi_safi = protocol.bgp.global_.afi_safis.AfiSafi()
afi_safi.afi_safi_name = oc_bgp_types.IPV4UNICAST()
afi_safi.config.afi_safi_name = oc_bgp_types.IPV4UNICAST()
afi_safi.config.enabled = True
protocol.bgp.global_.afi_safis.afi_safi.append(afi_safi)
if "peer-group-name" in list(bgp.keys()):
peer_group = protocol.bgp.peer_groups.PeerGroup()
peer_group.peer_group_name = bgp["peer-group-name"]
peer_group.config.peer_group_name = bgp["peer-group-name"]
if "peer-as" in list(bgp.keys()):
peer_group.config.peer_as = int(bgp["peer-as"])
if "peer-group-local-address" in list(bgp.keys()):
peer_group.transport.config.local_address = bgp[
"peer-group-local-address"]
afi_safi = peer_group.afi_safis.AfiSafi()
afi_safi.afi_safi_name = oc_bgp_types.IPV4UNICAST()
afi_safi.config.afi_safi_name = oc_bgp_types.IPV4UNICAST()
afi_safi.config.enabled = True
peer_group.afi_safis.afi_safi.append(afi_safi)
protocol.bgp.peer_groups.peer_group.append(peer_group)
if "neighbor" in list(bgp.keys()):
neighbor = protocol.bgp.neighbors.Neighbor()
neighbor.neighbor_address = bgp["neighbor"]
neighbor.config.neighbor_address = bgp["neighbor"]
#neighbor.config.peer_as = bgp["peer-as"]
if "peer-group-name" in list(bgp.keys()):
neighbor.config.peer_group = bgp["peer-group-name"]
afi_safi = neighbor.afi_safis.AfiSafi()
afi_safi.afi_safi_name = oc_bgp_types.IPV4UNICAST()
afi_safi.config.afi_safi_name = oc_bgp_types.IPV4UNICAST()
afi_safi.config.enabled = True
neighbor.afi_safis.afi_safi.append(afi_safi)
protocol.bgp.neighbors.neighbor.append(neighbor)
ni.protocols.protocol.append(protocol)
if crud_op == "add":
response = crud.create(provider, ni)
elif crud_op == "delete":
response = crud.delete(provider, ni)
elif crud_op is "update":
response = crud.update(provider, ni)
else:
print(
"Invalid operation requested, allowed values = add, update, delete"
)
return False
return response
device = urllib.parse.urlparse(args.device)
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create NETCONF provider
provider = NetconfServiceProvider(address=device.hostname,
port=device.port,
username=device.username,
password=device.password,
protocol=device.scheme)
# create CRUD service
crud = CRUDService()
# BGP configuration filter
bgp = oc_bgp.Bgp()
bgp_peer_remove_filter(bgp, args.local_as, args.peer_address)
# update configuration on NETCONF device
crud.update(provider, bgp)
exit()
# End of script
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create NETCONF provider
provider = NetconfServiceProvider(address=device.hostname,
port=device.port,
username=device.username,
password=device.password,
protocol=device.scheme)
# create CRUD service
crud = CRUDService()
# BGP configuration filter
network_instances = oc_network_instance.NetworkInstances()
bgp_peer_remove_filter(network_instances, int(args.local_as),
args.peer_address)
# update configuration on NETCONF device
crud.update(provider, network_instances)
exit()
# End of script
def create_l3_service(request, nc_provider):
# create CRUD service
crud = CRUDService()
# create codec provider
codec_provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
# interface configuration
interface_name = request['interface-name']
# create ifmgr obj
if_cfg = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration()
if_cfg.active = "act"
if_cfg.interface_name = interface_name
if_cfg.interface_mode_non_physical = xr_ifmgr_cfg.InterfaceModeEnum.default
if_cfg.statistics = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Statistics(
)
if_cfg.statistics.load_interval = 30
if_cfg.ipv4_network = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
)
if_cfg.ipv4_network.addresses = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
).Addresses()
primary_address = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
).Addresses().Primary()
primary_address.address = request['intf-ip']
primary_address.netmask = "255.255.255.252"
if_cfg.ipv4_network.addresses.primary = primary_address
if_cfg.vlan_sub_configuration = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration(
).VlanSubConfiguration()
if_cfg.vlan_sub_configuration.vlan_identifier = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration(
).VlanSubConfiguration().VlanIdentifier()
if_cfg.vlan_sub_configuration.vlan_identifier.first_tag = int(
request['vlan-id'])
encap_type = xr_eth_infra_dt.Vlan.vlan_type_dot1q
if_cfg.vlan_sub_configuration.vlan_identifier.vlan_type = encap_type
the_xml = codec.encode(codec_provider, if_cfg)
# logging.info(the_xml)
# create the interface configurations add the if_cfg to it
if_cfgs = xr_ifmgr_cfg.InterfaceConfigurations()
if_cfgs.interface_configuration.append(if_cfg)
if request['delete-config'] == 'off':
crud.create(nc_provider, if_cfgs)
elif request['delete-config'] == 'on':
crud.delete(nc_provider, if_cfg)
# global configuration
bgp = xr_ipv4_bgp_cfg.Bgp()
instance = bgp.Instance()
instance.instance_name = "default"
instance_as = instance.InstanceAs()
instance_as.as_ = 0
four_byte_as = instance_as.FourByteAs()
four_byte_as.as_ = int(request['bgp-as'])
four_byte_as.bgp_running = Empty()
# global address family
global_af = four_byte_as.default_vrf.global_.global_afs.GlobalAf()
global_af.af_name = xr_ipv4_bgp_datatypes.BgpAddressFamily.ipv4_unicast
global_af.enable = Empty()
global_af.sourced_networks = four_byte_as.default_vrf.global_.global_afs.GlobalAf(
).SourcedNetworks()
network = four_byte_as.default_vrf.global_.global_afs.GlobalAf(
).SourcedNetworks().SourcedNetwork()
addr_parsed = request['intf-ip'].split('.')
addr = addr_parsed[0] + "." + addr_parsed[1] + "." + addr_parsed[2] + ".0"
network.network_addr = addr
network.network_prefix = int(request['mask'])
global_af.sourced_networks.sourced_network.append(network)
four_byte_as.default_vrf.global_.global_afs.global_af.append(global_af)
instance_as.four_byte_as.append(four_byte_as)
instance.instance_as.append(instance_as)
bgp.instance.append(instance)
the_xml = codec.encode(codec_provider, bgp)
logging.info(the_xml)
if request['delete-config'] == 'off':
crud.create(nc_provider, bgp)
elif request['delete-config'] == 'on':
bgp_instance = bgp.instance['default']
sourced = bgp.instance['default'].instance_as['0'].four_byte_as[
request['bgp-as']].default_vrf.global_.global_afs.global_af[
'ipv4-unicast'].sourced_networks
sn = sourced.sourced_network[addr, int(request['mask'])]
sn.yfilter = YFilter.delete
crud.update(nc_provider, bgp)
return
class SanityYang(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityYang.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def read_from_empty_filter(self):
empty_runner = ysanity.Runner()
return self.crud.read(self.ncc, empty_runner)
def get_nested_object(self):
# return nested object with selected list elements
runner_create = ysanity.Runner()
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner:inbtwlist:[11]:name'
e_1.subc.number = 111
e_1.subc.name = 'runner:inbtwlist:[11]:subc:name'
e_2.number = 12
e_2.name = 'runner:inbtwlist:[12]:name'
e_2.subc.number = 121
e_2.subc.name = 'runner:inbtwlist:[12]:name'
e_11 = e_1.subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner:inbtwlist:[11]:subc:subcsubl1[111]:name'
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner:inbtwlist:[11]:subc:subcsubl1[112]:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner:inbtwlist:[12]:subc:subcsubl1[121]:name'
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner:inbtwlist:[12]:subc:subcsubl1[122]:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
runner_create.inbtw_list.ldata.extend([e_1, e_2])
return runner_create, e_2, e_22
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_on_leaflist_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend(
[str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
elements_to_delete = runner_create.ytypes.built_in_t.llstring[0:2]
self.crud.delete(self.ncc, elements_to_delete)
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[0:2]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_on_leaflist(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend(
[str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
self.crud.delete(self.ncc, runner_create.ytypes.built_in_t.llstring[3])
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[3]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_on_list_with_identitykey(self):
runner = ysanity.Runner()
a1 = ysanity.Runner.OneList.IdentityList()
a1.config.id = ysanity.ChildIdentityIdentity()
a1.id_ref = a1.config.id
runner.one_list.identity_list.extend([a1])
self.crud.create(self.ncc, runner)
empty_runner = ysanity.Runner()
runner_read = self.crud.read(self.ncc, empty_runner)
self.crud.delete(self.ncc, runner_read.one_list.identity_list)
runner_read = self.crud.read(self.ncc, empty_runner)
self.assertEqual(len(runner_read.one_list.identity_list), 0)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc,
runner_read.inbtw_list.ldata[1].subc.subc_subl1)
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
del runner_left.inbtw_list.ldata[1].subc.subc_subl1[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list_with_key(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc,
runner_create.inbtw_list.ldata[1].subc.subc_subl1[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata[1].subc.subc_subl1.remove(e_22)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_with_key(self):
runner_create, e_2, _ = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata.remove(e_2)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
baz = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
baz.number = 3
baz.name = 'baz'
runner_create.one_list.ldata.extend([foo, bar, baz])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
elements_to_delete = runner_read.one_list.ldata[:1]
self.crud.delete(self.ncc, elements_to_delete)
# read after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete entire list
del runner_left.one_list.ldata[:1]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
runner_create.one_list.ldata.extend([foo, bar])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.one_list.ldata)
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class SanityGnmiCrud(unittest.TestCase):
@classmethod
def setUpClass(self):
self.codec_provider = CodecServiceProvider()
self.codec = CodecService()
self.repo = Repository(get_local_repo_dir())
self.provider = gNMIServiceProvider( self.repo, "127.0.0.1", "admin", "admin", port=50051)
self.schema = self.provider.get_session().get_root_schema()
self.crud = CRUDService()
def test_gnmi_crud_all_operations(self):
# Configure interface
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config.name = 'Loopback10'
# Configure BGP
bgp_global_config = openconfig_bgp.Bgp.Global.Config()
bgp_global_config.as_ = 65172
neighbor = openconfig_bgp.Bgp.Neighbors.Neighbor()
neighbor.neighbor_address = '172.16.255.2'
neighbor.config.neighbor_address = '172.16.255.2'
neighbor.config.peer_as = 65172
res = self.crud.create(self.provider, [lo10, bgp_global_config, neighbor])
# Update configuration
lo10.config.description = 'Test'
res = self.crud.update(self.provider, lo10)
self.assertTrue(res)
# Read all
read_list = self.crud.read(self.provider, [openconfig_interfaces.Interfaces(), openconfig_bgp.Bgp()])
# Read config
ifc_filter = openconfig_interfaces.Interfaces.Interface()
ifc_filter.name = 'Loopback10'
bgp_neighbor_filter = openconfig_bgp.Bgp.Neighbors.Neighbor()
bgp_neighbor_filter.neighbor_address = '172.16.255.2'
read_list = self.crud.read_config(self.provider, [ifc_filter, bgp_neighbor_filter])
self.assertIsNotNone(read_list)
self.assertEqual(isinstance(read_list, list), True)
self.assertEqual(len(read_list), 2)
#for entity in read_list:
# print_entity(entity, self.schema)
# Read single container
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config = YFilter.read
ifc_config = self.crud.read(self.provider, lo10)
#print_entity(ifc_config, self.schema)
expected = '''<interface>
<name>Loopback10</name>
<config>
<name>Loopback10</name>
<description>Test</description>
</config>
</interface>
'''
self.assertEqual( entity_to_string(ifc_config, self.schema), expected)
# Read single leaf
ifcs = openconfig_interfaces.Interfaces()
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config.description = YFilter.read
ifcs.interface.append(lo10)
read_descr = self.crud.read(self.provider, lo10)
#print_entity(read_descr, self.schema)
expected = '''<interface>
<name>Loopback10</name>
<config>
<description>Test</description>
</config>
</interface>
'''
self.assertEqual( entity_to_string(read_descr, self.schema), expected)
# Delete configuration
ifc = openconfig_interfaces.Interfaces.Interface()
ifc.name = 'Loopback10'
bgp = openconfig_bgp.Bgp()
res = self.crud.delete(self.provider, [ifc, bgp])
def test_gnmi_crud_with_no_validation(self):
# Configure interface
ifc_config = openconfig_interfaces.Interfaces()
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config.name = 'Loopback10'
lo10.ignore_validation = True
ifc_config.interface.append(lo10)
# Configure BGP
bgp_config = openconfig_bgp.Bgp()
bgp_config.global_.config.as_ = 65172
bgp_config.ignore_validation = True
neighbor = openconfig_bgp.Bgp.Neighbors.Neighbor()
neighbor.neighbor_address = '172.16.255.2'
neighbor.config.neighbor_address = '172.16.255.2'
neighbor.config.peer_as = 65172
bgp_config.neighbors.neighbor.append(neighbor)
res = self.crud.create(self.provider, [lo10, bgp_config])
# Update configuration
lo10.config.description = 'Test'
res = self.crud.update(self.provider, lo10)
self.assertTrue(res)
# Read config
ifc_filter = openconfig_interfaces.Interfaces()
ifc = openconfig_interfaces.Interfaces.Interface()
ifc.name = 'Loopback10'
ifc.ignore_validation = True
ifc_filter.interface.append(ifc)
bgp_filter = openconfig_bgp.Bgp()
bgp_neighbor_filter = openconfig_bgp.Bgp.Neighbors.Neighbor()
bgp_neighbor_filter.neighbor_address = '172.16.255.2'
bgp_neighbor_filter.ignore_validation = True
bgp_filter.neighbors.neighbor.append(bgp_neighbor_filter)
read_list = self.crud.read_config(self.provider, [ifc, bgp_neighbor_filter])
self.assertIsNotNone(read_list)
self.assertEqual(isinstance(read_list, list), True)
self.assertEqual(len(read_list), 2)
# Read single container
ifc_filter = openconfig_interfaces.Interfaces()
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config = YFilter.read
lo10.ignore_validation = True
ifc_filter.interface.append(lo10)
ifc_read = self.crud.read(self.provider, lo10)
expected = '''<interface>
<name>Loopback10</name>
<config>
<name>Loopback10</name>
<description>Test</description>
</config>
</interface>
'''
self.assertEqual( entity_to_string(ifc_read, self.schema), expected)
# Read single leaf
ifcs = openconfig_interfaces.Interfaces()
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config.description = YFilter.read
ifcs.interface.append(lo10)
ifcs.ignore_validation = True
read_descr = self.crud.read(self.provider, lo10)
expected = '''<interface>
<name>Loopback10</name>
<config>
<description>Test</description>
</config>
</interface>
'''
self.assertEqual( entity_to_string(read_descr, self.schema), expected)
# Delete configuration
ifc = openconfig_interfaces.Interfaces.Interface()
ifc.name = 'Loopback10'
bgp = openconfig_bgp.Bgp()
res = self.crud.delete(self.provider, [ifc, bgp])
proto = 'ssh'
if __name__ == '__main__':
provider = NetconfServiceProvider(address=ip,
port=port_n,
username=user,
password=paswd,
protocol=proto)
crud = CRUDService()
# get hold of only the fifth GigabitEthernet interface without the other interfaces
xe_int_giga = xe_model.Native.Interface.GigabitEthernet()
xe_int_giga.name = '5'
# read the interface
intf_data = crud.read(provider, xe_int_giga)
# print the primary addres of the interface
print(intf_data.ip.address.primary.address)
# update the description of the interface
intf_data.description = 'interface description'
crud.update(provider, intf_data)
# print the description of the interface
print(intf_data.description)
exit()
class YDKCrudService(object):
"""Contains methods for sending create/read/update/delete operations over a YDK provider"""
__existing_connections = {}
def __init__(self):
self._session = None
self._crud = CRUDService()
def _open_provider_session(self,
node,
protocol="netconf",
provider_proto='default'):
def netconf():
"""
Return the YDK netconf provider
"""
if provider_proto == 'default':
netconf_proto = 'ssh'
else:
netconf_proto = provider_proto
provider = YDKNetconfProvider(netconf_proto)
self._session = provider.open_netconf_session(node)
return self._session
def grpc():
##TODO: when grpc gets implemented by YDK as a provider.
return None
provider_dict = {'netconf': netconf(), 'grpc': grpc()}
return provider_dict[protocol]
def _close_provider_session(self, node):
def netconf():
"""
Return the YDK netconf provider
"""
provider = YDKNetconfProvider()
self._session = provider.close_netconf_session(node)
return self._session
def grpc():
##TODO: when grpc gets implemented by YDK as a provider.
return None
provider_dict = {'netconf': netconf(), 'grpc': grpc()}
return provider_dict[protocol]
def create(self,
entity,
node,
protocol="netconf",
provider_proto='default'):
"""Invoke a crud.create for a given entity on a node using the specified protocol.
"""
# Open up the provider session if necessary
self._open_provider_session(node, protocol, provider_proto)
# Initiate a crud.create on the selected provider
self._crud.create(self._session, entity)
logger.debug('Crud Create Successful')
def read(self, entity, node, protocol="netconf", provider_proto='default'):
"""Invoke a crud.create for a given entity on a node using the specified protocol.
"""
# Open up the provider session if necessary
self._open_provider_session(node, protocol, provider_proto)
# Initiate a crud.create on the selected provider
self._crud.read(self._session, entity)
logger.debug('Crud Read Successful')
def update(self,
entity,
node,
protocol="netconf",
provider_proto='default'):
"""Invoke a crud.create for a given entity on a node using the specified protocol.
"""
# Open up the provider session if necessary
self._open_provider_session(node, protocol, provider_proto)
# Initiate a crud.create on the selected provider
self._crud.update(self._session, entity)
logger.debug('Crud Update Successful')
def delete(self,
entity,
node,
protocol="netconf",
provider_proto='default'):
"""Invoke a crud.create for a given entity on a node using the specified protocol.
"""
# Open up the provider session if necessary
self._open_provider_session(node, protocol, provider_proto)
# Initiate a crud.create on the selected provider
self._crud.delete(self._session, entity)
logger.debug('Crud Delete Successful')
class SanityTest(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityTest.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
self.ncc.close()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def _create_runner(self):
runner = Runner()
runner.ytypes = runner.Ytypes()
runner.ytypes.built_in_t = runner.ytypes.BuiltInT()
return runner
def test_int8(self):
# Create Runner
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = 126
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = 200000
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_bits(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bits_value['disable-nagle'] = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = -9223372036854775808
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint8(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 65535
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 5927
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = 18446744073709551615
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_decimal64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.deci64 = Decimal64('3.14')
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_string_1(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = 'name_str'
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_string_2(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = b'name_str'
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
runner.ytypes.built_in_t.name = 'name_str'
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_empty(self):
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = Empty()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# explicit DELETE not support at the moment
# runner1.ytypes.built_in_t.emptee = DELETE()
# self.crud.update(self.ncc, runner1)
# runner2 = self.crud.read(self.ncc, self._create_runner())
# self.assertEqual(runner2.ytypes.built_in_t.emptee, None)
def test_boolean(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.crud.update(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_embedded_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.embeded_enum = Runner.Ytypes.BuiltInT.EmbededEnumEnum.zero
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = YdkEnumTestEnum.none
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion = YdkEnumTestEnum.none
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = YdkEnumIntTestEnum.any
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_int(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = 2
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_recursive(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion_recursive = 18
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_list(self):
runner = self._create_runner()
runner.ytypes.built_in_t.llunion.append(1)
runner.ytypes.built_in_t.llunion.append(3)
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('ConfD internal error.')
def test_bits_leaflist(self):
# User needs to append Bits instance manually to bits leaflist.
runner = self._create_runner()
bits_0 = runner.ytypes.built_in_t.BitsLlist_Bits()
bits_1 = runner.ytypes.built_in_t.BitsLlist_Bits()
bits_0['disable-nagle'] = True
bits_1['auto-sense-speed'] = True
runner.ytypes.built_in_t.bits_llist.extend([bits_0, bits_1])
self.crud.create(self.ncc, runner)
# Read into Runner1
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_enum_leaflist(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_llist.append(YdkEnumTestEnum.local)
runner.ytypes.built_in_t.enum_llist.append(YdkEnumTestEnum.remote)
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_identity_leaflist(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_llist.append(ChildIdentityIdentity())
runner.ytypes.built_in_t.identity_llist.append(
ChildChildIdentityIdentity())
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
#DEEPCOPY
runner_copy = copy.deepcopy(runner)
# result = is_equal(runner, runner_copy)
# self.assertEqual(result, True)
self.crud.delete(self.ncc, Runner())
self.crud.create(self.ncc, runner_copy)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_complex_list(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion_list.append('123:45')
runner.ytypes.built_in_t.younion_list.append(23)
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
union_list = runner.ytypes.built_in_t.younion_list
self.assertTrue(23 in union_list and '123:45' in union_list)
def test_identityref(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
ChildIdentityIdentity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_status_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.status = runner.ytypes.built_in_t.StatusEnum.not_connected
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_leaflist_unique(self):
runner = self._create_runner()
with self.assertRaises(YPYModelError):
runner.ytypes.built_in_t.llstring.extend([None for i in range(3)])
def test_list_max_elements(self):
runner = self._create_runner()
elems = []
n = 10
for i in range(n):
l = Runner.OneList.Ldata()
l.number = i
l.name = str(i)
elems.append(l)
runner.one_list.ldata.extend(elems)
self.assertRaises(YPYModelError, self.crud.create, self.ncc, runner)
def test_submodule(self):
subtest = SubTest()
subtest.one_aug.name = 'test'
subtest.one_aug.number = 3
res = self.crud.create(self.ncc, subtest)
subtest1 = self.crud.read(self.ncc, SubTest())
# Compare runners
result = is_equal(subtest, subtest1)
self.assertEqual(result, True)
def test_identity_from_other_module(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
YdktestTypeIdentity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
class SanityCrud(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityCrud.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def _create_runner(self):
runner = ysanity.Runner()
runner.ytypes = runner.Ytypes()
runner.ytypes.built_in_t = runner.ytypes.BuiltInT()
return runner
def test_crud_create_invalid_1(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(None, runner)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_crud_create_invalid_2(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_crud_create_invalid_3(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_crud_delete_invalid_1(self):
try:
runner = self._create_runner()
self.crud.delete(None, runner)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_delete_invalid_2(self):
try:
self.crud.delete(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_delete_invalid_3(self):
try:
self.crud.delete(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_read_invalid_1(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
self.crud.read(None, runner1)
except YPYServiceError as err:
expected_msg = "'provider' and 'read_filter' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_read_invalid_2(self):
try:
self.crud.read(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'read_filter' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_read_invalid_3(self):
try:
self.crud.read(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'read_filter' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_update_invalid_1(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.crud.update(None, runner)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_update_invalid_2(self):
try:
self.crud.update(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_update_invalid_3(self):
try:
self.crud.update(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(
address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def read_from_empty_filter(self):
empty_runner = ysanity.Runner()
return self.crud.read(self.ncc, empty_runner)
def get_nested_object(self):
# return nested object with selected list elements
runner_create = ysanity.Runner()
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner:inbtwlist:['+str(e_1.number)+']:name'
e_1.subc.number = 111
e_1.subc.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:name'
e_2.number = 12
e_2.name = 'runner:inbtwlist:['+str(e_2.number)+']:name'
e_2.subc.number = 121
e_2.subc.name = 'runner:inbtwlist:['+str(e_2.number)+']:name'
e_11 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:subcsubl1['+str(e_11.number)+']:name'
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:subcsubl1['+str(e_12.number)+']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner:inbtwlist:['+str(e_2.number)+']:subc:subcsubl1['+str(e_21.number)+']:name'
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner:inbtwlist:['+str(e_2.number)+']:subc:subcsubl1['+str(e_22.number)+']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
runner_create.inbtw_list.ldata.extend([e_1, e_2])
return runner_create, e_2, e_22
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_on_leaflist_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend([str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
elements_to_delete = runner_create.ytypes.built_in_t.llstring[0:2]
self.crud.delete(self.ncc, elements_to_delete)
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[0:2]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_on_leaflist(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend([str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
self.crud.delete(self.ncc, runner_create.ytypes.built_in_t.llstring[3])
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[3]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1].subc.subc_subl1)
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
del runner_left.inbtw_list.ldata[1].subc.subc_subl1[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list_with_key(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1].subc.subc_subl1[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata[1].subc.subc_subl1.remove(e_22)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_with_key(self):
runner_create, e_2, _ = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata.remove(e_2)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
baz = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
baz.number = 3
baz.name = 'baz'
runner_create.one_list.ldata.extend([foo, bar, baz])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
elements_to_delete = runner_read.one_list.ldata[:1]
self.crud.delete(self.ncc, elements_to_delete)
# read after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete entire list
del runner_left.one_list.ldata[:1]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
runner_create.one_list.ldata.extend([foo, bar])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.one_list.ldata)
# read after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete entire list
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
print "\nIn method", self._testMethodName
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def _create_runner(self):
runner = ysanity.Runner()
runner.ytypes = runner.Ytypes()
runner.ytypes.built_in_t = runner.ytypes.BuiltInT()
return runner
# def test_invalids(self):
# runner = self._create_runner()
# runner.ytypes.built_in_t.name = []
# runner.ytypes.built_in_t.u_number8 = -1
# runner.ytypes.built_in_t.enum_value = ''
# self.crud.create(self.ncc, runner)
# with self.assertRaises(YPYDataValidationError):
# self.crud.create(self.ncc, runner)
def test_int8(self):
# Create Runner
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int8_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 8.5
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # invalid object is not equal
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_int16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = 126
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int16_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = {}
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_int32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = 200000
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int32_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = []
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_bits(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bits_value['disable-nagle'] = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = -9223372036854775808
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int64_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = 9223372036854775808
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_uint8(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_uint8_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = -1
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_uint16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 65535
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_unint16_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 'not an uint'
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_uint32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 5927
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_unint32_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 4294967296
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_decimal64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.deci64 = Decimal64('3.14')
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('Revisit implementation')
def test_uint64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = 18446744073709551615
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_uint64_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = 18446744073709551616
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_string(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = 'name_str'
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# but invalid input is sent to the device
def test_string_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = ['name_str']
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# self.crud.create(self.ncc, runner)
# Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_empty(self):
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = Empty()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# explicit DELETE not support at the moment
# runner1.ytypes.built_in_t.emptee = DELETE()
# self.crud.update(self.ncc, runner1)
# runner2 = self.crud.read(self.ncc, self._create_runner())
# self.assertEqual(runner2.ytypes.built_in_t.emptee, None)
def test_empty_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = 0
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# Read into Runner2
# runner1 = ysanity.Runner()
# self.assertRaises(YPYDataValidationError,
# self.crud.create, self.ncc, runner)
# runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_boolean(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.crud.update(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('boolean type will convert empty string to false')
def test_boolean_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = ''
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, True)
def test_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = YdkEnumTestEnum.NONE
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_enum_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = 'not an enum'
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
# OLD
# with self.assertRaises(YPYError) as e:
# self.crud.create(self.ncc, runner)
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_union(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion = YdkEnumTestEnum.NONE
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = YdkEnumIntTestEnum.ANY
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_int(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = 2
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_identityref(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
ysanity.ChildIdentity_Identity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# Will only test max-elements. If min-elements is set, then this
# constraint is required for every READ/UPDATE operation. So it will fail all other cases.
def test_leaflist_max_elements(self):
runner = self._create_runner()
runner.ytypes.built_in_t.llstring = [str(i) for i in range(30)]
runner.ytypes.built_in_t.llstring.extend([None for i in range(20)])
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
def test_list_max_elements(self):
runner = self._create_runner()
elems = []
n = 10
for i in range(n):
l = ysanity.Runner.OneList.Ldata()
l.number = i
l.name = str(i)
elems.append(l)
runner.one_list.ldata.extend(elems)
self.assertRaises(YPYDataValidationError, self.crud.create, self.ncc,
runner)
def test_submodule(self):
subtest = ysanity.SubTest()
subtest.one_aug.name = 'test'
subtest.one_aug.number = 3
res = self.crud.create(self.ncc, subtest)
subtest1 = self.crud.read(self.ncc, ysanity.SubTest())
# Compare runners
result = is_equal(subtest, subtest1)
self.assertEqual(result, True)
def test_identity_from_other_module(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
ysanity_types.YdktestType_Identity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(
address='127.0.0.1', username='******',
password='******', protocol='ssh', port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
@unittest.skip('DELETE object for leaf-list')
def test_delete_object_on_leaflist(self):
# create runner with a leaf and a leaflist
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring = [str(i) for i in range(5)]
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# user DELETE object to remove leaflist
runner_delete = runner_read
runner_delete.ytypes.built_in_t.llstring = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf one
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
# create runner with a container and a list
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
elem1 = ysanity.Runner.OneList.Ldata()
elem2 = ysanity.Runner.OneList.Ldata()
elem1.number = 1
elem2.name = 'foo'
elem2.number = 1
elem2.name = 'bar'
runner_create.one_list.ldata.extend([elem1, elem2])
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
self.crud.delete(self.ncc, runner_read.one_list.ldata)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class SanityYang(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityYang.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def test_one_level_pos(self):
# READ
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.one.number, r_1.one.name = 10, 'runner/one/name'
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_two_level_pos(self):
# READ
r_1 = ysanity.Runner()
r_1.two.number, r_1.two.name, r_1.two.sub1.number = 2, 'runner:two:name', 21
self.crud.create(self.ncc, r_1)
r_2 = ysanity.Runner()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.two.number, r_1.two.name, r_1.two.sub1.number = 20, 'runner/two/name', 210
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_three_level_pos(self):
# READ
r_1 = ysanity.Runner()
r_1.three.number, r_1.three.name, \
r_1.three.sub1.number, r_1.three.sub1.sub2.number = 3, 'runner:three:name', 31, 311
self.crud.create(self.ncc, r_1)
r_2 = ysanity.Runner()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.three.number, r_1.three.name, \
r_1.three.sub1.number, r_1.three.sub1.sub2.number = 30, 'runner/three/name', 310, 3110
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_onelist_neg_dupkey(self):
# netsim/enxr not complaining
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1, e_2 = ysanity.Runner.OneList.Ldata(), ysanity.Runner.OneList.Ldata()
e_1.number = 1
e_2.name = 'foo'
e_2.number = 1
e_2.name = 'bar'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
def test_onelist_neg_update_key_nonexist(self):
# will create a nonexist elem
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1, e_2 = ysanity.Runner.OneList.Ldata(), ysanity.Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata['+str(e_1.number)+']:name'
r_1.one_list.ldata.extend([e_1])
self.crud.create(self.ncc, r_1)
r_1.one_list.ldata[0].number = 2
r_1.one_list.ldata[0].name = '2'
# assuming update on nonexist key will raise Exception
with self.assertRaises(Exception):
self.crud.update(self.ncc, r_1.one_list.ldata[0])
def test_onelsit_pos(self):
# READ
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1, e_2 = ysanity.Runner.OneList.Ldata(), ysanity.Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata['+str(e_1.number)+']:name'
e_2.number = 2
e_2.name = 'runner:onelist:ldata['+str(e_2.number)+']:name'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1, e_2 = ysanity.Runner.OneList.Ldata(), ysanity.Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata['+str(e_1.number)+']:name'
e_2.number = 2
e_2.name = 'runner:onelist:ldata['+str(e_2.number)+']:name'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_twolist_pos(self):
# READ
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1, e_2 = ysanity.Runner.TwoList.Ldata(), ysanity.Runner.TwoList.Ldata()
e_11, e_12 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner:twolist:ldata['+str(e_1.number)+']:name'
e_11.number = 211
e_11.name = 'runner:twolist:ldata['+str(e_1.number)+']:subl1['+str(e_11.number)+']:name'
e_12.number = 212
e_12.name = 'runner:twolist:ldata['+str(e_1.number)+']:subl1['+str(e_12.number)+']:name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner:twolist:ldata['+str(e_2.number)+']:name'
e_21.number = 221
e_21.name = 'runner:twolist:ldata['+str(e_2.number)+']:subl1['+str(e_21.number)+']:name'
e_22.number = 222
e_22.name = 'runner:twolist:ldata['+str(e_2.number)+']:subl1['+str(e_22.number)+']:name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1, e_2 = ysanity.Runner.TwoList.Ldata(), ysanity.Runner.TwoList.Ldata()
e_11, e_12 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner/twolist/ldata['+str(e_1.number)+']/name'
e_11.number = 211
e_11.name = 'runner/twolist/ldata['+str(e_1.number)+']/subl1['+str(e_11.number)+']/name'
e_12.number = 212
e_12.name = 'runner/twolist/ldata['+str(e_1.number)+']/subl1['+str(e_12.number)+']/name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner/twolist/ldata['+str(e_2.number)+']/name'
e_21.number = 221
e_21.name = 'runner/twolist/ldata['+str(e_2.number)+']/subl1['+str(e_21.number)+']/name'
e_22.number = 222
e_22.name = 'runner/twolist/ldata['+str(e_2.number)+']/subl1['+str(e_22.number)+']/name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_threelist_pos(self):
# READ
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1 = ysanity.Runner.ThreeList.Ldata()
e_1.number = 31
e_1.name = 'runner:threelist:ldata['+str(e_1.number)+']:name'
e_2 = ysanity.Runner.ThreeList.Ldata()
e_2.number = 32
e_2.name = 'runner:threelist:ldata['+str(e_2.number)+']:name'
e_11 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_12 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_11.number = 311
e_11.name = 'runner:threelist:ldata['+str(e_1.number)+']:subl1['+str(e_11.number)+']:name'
e_12.number = 312
e_12.name = 'runner:threelist:ldata['+str(e_1.number)+']:subl1['+str(e_12.number)+']:name'
e_111 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_112 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_111.number = 3111
e_111.name = 'runner:threelist:ldata['+str(e_1.number)+']:subl1['+str(e_11.number)+']:subsubl1['+str(e_111.number)+']:name'
e_112.number = 3112
e_112.name = 'runner:threelist:ldata['+str(e_1.number)+']:subl1['+str(e_11.number)+']:subsubl1['+str(e_112.number)+']:name'
e_11.sub_subl1.extend([e_111, e_112])
e_121 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_122 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_121.number = 3121
e_121.name = 'runner:threelist:ldata['+str(e_1.number)+']:subl1['+str(e_12.number)+']:subsubl1['+str(e_121.number)+']:name'
e_122.number = 3122
e_121.name = 'runner:threelist:ldata['+str(e_1.number)+']:subl1['+str(e_12.number)+']:subsubl1['+str(e_122.number)+']:name'
e_12.sub_subl1.extend([e_121, e_122])
e_1.subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_22 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_21.number = 321
e_21.name = 'runner:threelist:ldata['+str(e_2.number)+']:subl1['+str(e_21.number)+']:name'
e_22.number = 322
e_22.name = 'runner:threelist:ldata['+str(e_2.number)+']:subl1['+str(e_22.number)+']:name'
e_211 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_212 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_211.number = 3211
e_211.name = 'runner:threelist:ldata['+str(e_2.number)+']:subl1['+str(e_21.number)+']:subsubl1['+str(e_211.number)+']:name'
e_212.number = 3212
e_212.name = 'runner:threelist:ldata['+str(e_2.number)+']:subl1['+str(e_21.number)+']:subsubl1['+str(e_212.number)+']:name'
e_21.sub_subl1.extend([e_211, e_212])
e_221 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_222 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_221.number = 3221
e_221.name = 'runner:threelist:ldata['+str(e_2.number)+']:subl1['+str(e_22.number)+']:subsubl1['+str(e_221.number)+']:name'
e_222.number = 3222
e_222.name = 'runner:threelist:ldata['+str(e_2.number)+']:subl1['+str(e_22.number)+']:subsubl1['+str(e_222.number)+']:name'
e_22.sub_subl1.extend([e_221, e_222])
e_2.subl1.extend([e_21, e_22])
r_1.three_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1 = ysanity.Runner.ThreeList.Ldata()
e_1.number = 31
e_1.name = 'runner/threelist/ldata['+str(e_1.number)+']/name'
e_2 = ysanity.Runner.ThreeList.Ldata()
e_2.number = 32
e_2.name = 'runner/threelist/ldata['+str(e_2.number)+']/name'
e_11 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_12 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_11.number = 311
e_11.name = 'runner/threelistldata['+str(e_1.number)+']/subl1['+str(e_11.number)+']/name'
e_12.number = 312
e_12.name = 'runner/threelist/ldata['+str(e_1.number)+']/subl1['+str(e_12.number)+']/name'
e_111 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_112 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_111.number = 3111
e_111.name = 'runner/threelist/ldata['+str(e_1.number)+']/subl1['+str(e_11.number)+']/subsubl1['+str(e_111.number)+']/name'
e_112.number = 3112
e_112.name = 'runner/threelist/ldata['+str(e_1.number)+']/subl1['+str(e_11.number)+']/subsubl1['+str(e_112.number)+']/name'
e_11.sub_subl1.extend([e_111, e_112])
e_121 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_122 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_121.number = 3121
e_121.name = 'runner/threelist/ldata['+str(e_1.number)+']/subl1['+str(e_12.number)+']/subsubl1['+str(e_121.number)+']/name'
e_122.number = 3122
e_121.name = 'runner/threelist/ldata['+str(e_1.number)+']/subl1['+str(e_12.number)+']/subsubl1['+str(e_122.number)+']/name'
e_12.sub_subl1.extend([e_121, e_122])
e_1.subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_22 = ysanity.Runner.ThreeList.Ldata.Subl1()
e_21.number = 321
e_21.name = 'runner/threelist/ldata['+str(e_2.number)+']/subl1['+str(e_21.number)+']/name'
e_22.number = 322
e_22.name = 'runner/threelist/ldata['+str(e_2.number)+']/subl1['+str(e_22.number)+']/name'
e_211 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_212 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_211.number = 3211
e_211.name = 'runner/threelist/ldata['+str(e_2.number)+']/subl1['+str(e_21.number)+']/subsubl1['+str(e_211.number)+']/name'
e_212.number = 3212
e_212.name = 'runner/threelist/ldata['+str(e_2.number)+']/subl1['+str(e_21.number)+']/subsubl1['+str(e_212.number)+']/name'
e_21.sub_subl1.extend([e_211, e_212])
e_221 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_222 = ysanity.Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_221.number = 3221
e_221.name = 'runner/threelist/ldata['+str(e_2.number)+']/subl1['+str(e_22.number)+']/subsubl1['+str(e_221.number)+']/name'
e_222.number = 3222
e_222.name = 'runner/threelist/ldata['+str(e_2.number)+']/subl1['+str(e_22.number)+']/subsubl1['+str(e_222.number)+']/name'
e_22.sub_subl1.extend([e_221, e_222])
e_2.subl1.extend([e_21, e_22])
r_1.three_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_InbtwList_pos(self):
# READ
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner:inbtwlist:['+str(e_1.number)+']:name'
e_1.subc.number = 111
e_1.subc.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:name'
e_2.number = 12
e_2.name = 'runner:inbtwlist:['+str(e_2.number)+']:name'
e_2.subc.number = 121
e_2.subc.name = 'runner:inbtwlist:['+str(e_2.number)+']:name'
e_11 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:subcsubl1['+str(e_11.number)+']:name'
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:subcsubl1['+str(e_12.number)+']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner:inbtwlist:['+str(e_2.number)+']:subc:subcsubl1['+str(e_21.number)+']:name'
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner:inbtwlist:['+str(e_2.number)+']:subc:subcsubl1['+str(e_22.number)+']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner/inbtwlist/['+str(e_1.number)+']/name'
e_1.subc.number = 111
e_1.subc.name = 'runnerinbtwlist/['+str(e_1.number)+']/subc/name'
e_2.number = 12
e_2.name = 'runner/inbtwlist/['+str(e_2.number)+']/name'
e_2.subc.number = 121
e_2.subc.name = 'runner/inbtwlist/['+str(e_2.number)+']/name'
e_11 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner/inbtwlist/['+str(e_1.number)+']/subc/subcsubl1['+str(e_11.number)+']/name'
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner/inbtwlist/['+str(e_1.number)+']/subc/subcsubl1['+str(e_12.number)+']/name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner/inbtwlist/['+str(e_2.number)+']/subc/subcsubl1['+str(e_21.number)+']/name'
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner/inbtwlist/['+str(e_2.number)+']/subc/subcsubl1['+str(e_22.number)+']/name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_leafref_simple_pos(self):
# change ref and original data together
# READ
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.ytypes.built_in_t.number8 = 100
r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.ytypes.built_in_t.number8 = 110
r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_leafref_pos(self):
# rfc: refer to leaf
# 1.already exists
# 2.has default value
# create leafs will be referred to
# CREATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.one.name = 'runner:one:name'
r_1.two.sub1.number = 21
r_1.three.sub1.sub2.number = 311
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_2.number = 21
e_1.name = 'runner:inbtwlist['+str(e_1.number)+']:name'
e_2.name = 'runner:inbtwlist['+str(e_2.number)+']:name'
e_1.subc.number = 111
e_2.subc.number = 121
e_1.subc.name = 'runner:inbtwlist['+str(e_1.number)+']:subc:name'
e_2.subc.name = 'runner:inbtwlist['+str(e_2.number)+']:subc:name'
e_11 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_12.number = 112
e_11.name = 'runner:inbtwlist['+str(e_1.number)+']:subc:subcsubl1['+str(e_11.number)+']:name'
e_12.name = 'runner:inbtwlist['+str(e_1.number)+']:subc:subcsubl1['+str(e_12.number)+']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 311
e_22.number = 122
e_21.name = 'runner:inbtwlist['+str(e_2.number)+']:subc:subcsubl1['+str(e_21.number)+']:name'
e_22.name = 'runner:inbtwlist['+str(e_2.number)+']:subc:subcsubl1['+str(e_22.number)+']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
r_1.leaf_ref.ref_one_name = r_1.one.name
r_1.leaf_ref.ref_two_sub1_number = r_1.two.sub1.number
r_1.leaf_ref.ref_three_sub1_sub2_number = r_1.three.sub1.sub2.number
r_1.leaf_ref.ref_inbtw = e_21.name
r_1.leaf_ref.one.name = 'runner:leaf-ref:one:name'
r_1.leaf_ref.one.two.self_ref_one_name = r_1.leaf_ref.ref_one_name
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_1.one.name, r_1.leaf_ref.ref_one_name)
self.assertEqual(r_1.two.sub1.number, r_1.leaf_ref.ref_two_sub1_number)
self.assertEqual(r_1.three.sub1.sub2.number, r_1.leaf_ref.ref_three_sub1_sub2_number)
self.assertEqual(r_1.inbtw_list.ldata[1].subc.subc_subl1[0].name, r_1.leaf_ref.ref_inbtw)
self.assertEqual(r_1.leaf_ref.ref_one_name, r_1.leaf_ref.one.two.self_ref_one_name)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.one.name = 'runner/one/name'
r_1.two.sub1.number = 21
r_1.three.sub1.sub2.number = 311
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_2.number = 21
e_1.name = 'runner/inbtwlist['+str(e_1.number)+']/name'
e_2.name = 'runner/inbtwlist['+str(e_2.number)+']/name'
e_1.subc.number = 111
e_2.subc.number = 121
e_1.subc.name = 'runner/inbtwlist['+str(e_1.number)+']/subc/name'
e_2.subc.name = 'runner/inbtwlist['+str(e_2.number)+']/subc/name'
e_11 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_12.number = 112
e_11.name = 'runner/inbtwlist['+str(e_1.number)+']/subc/subcsubl1['+str(e_11.number)+']/name'
e_12.name = 'runner/inbtwlist['+str(e_1.number)+']/subc/subcsubl1['+str(e_12.number)+']/name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 311
e_22.number = 122
e_21.name = 'runner/inbtwlist['+str(e_2.number)+']/subc/subcsubl1['+str(e_21.number)+']/name'
e_22.name = 'runner/inbtwlist['+str(e_2.number)+']/subc/subcsubl1['+str(e_22.number)+']/name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
r_1.leaf_ref.ref_one_name = r_1.one.name
r_1.leaf_ref.ref_two_sub1_number = r_1.two.sub1.number
r_1.leaf_ref.ref_three_sub1_sub2_number = r_1.three.sub1.sub2.number
r_1.leaf_ref.ref_inbtw = e_21.name
r_1.leaf_ref.one.name = 'runner/leaf-ref/one/name'
r_1.leaf_ref.one.two.self_ref_one_name = r_1.leaf_ref.ref_one_name
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_1.one.name, r_1.leaf_ref.ref_one_name)
self.assertEqual(r_1.two.sub1.number, r_1.leaf_ref.ref_two_sub1_number)
self.assertEqual(r_1.three.sub1.sub2.number, r_1.leaf_ref.ref_three_sub1_sub2_number)
self.assertEqual(r_1.inbtw_list.ldata[1].subc.subc_subl1[0].name, r_1.leaf_ref.ref_inbtw)
self.assertEqual(r_1.leaf_ref.ref_one_name, r_1.leaf_ref.one.two.self_ref_one_name)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_aug_one_pos(self):
# CREATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.one.one_aug.number = 1
r_1.one.one_aug.name =r_1.one.one_aug._common_path
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
r_1.one.one_aug.number = 10
r_1.one.one_aug.name =r_1.one.one_aug._common_path.replace(':', '/')
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_aug_onelist_pos(self):
# CREATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1 = ysanity.Runner.OneList.OneAugList.Ldata()
e_2 = ysanity.Runner.OneList.OneAugList.Ldata()
e_1.number = 1
e_1.name = e_1._common_path
e_2.number = 2
e_2.name = e_2._common_path
r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
r_1.one_list.one_aug_list.enabled = True
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = ysanity.Runner(), ysanity.Runner()
e_1 = ysanity.Runner.OneList.OneAugList.Ldata()
e_2 = ysanity.Runner.OneList.OneAugList.Ldata()
e_1.number = 1
e_1.name = e_1._common_path.replace(':', '/')
e_2.number = 2
e_2.name = e_2._common_path.replace(':', '/')
r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
r_1.one_list.one_aug_list.enabled = True
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = ysanity.Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_2._has_data(), False)
def test_parent_empty(self):
runner = ysanity.Runner()
runner.ytypes.enabled = Empty()
runner.ytypes.built_in_t.emptee = Empty()
self.crud.create(self.ncc, runner)
runner_read = self.crud.read(self.ncc, ysanity.Runner())
self.assertEqual(is_equal(runner_read, runner), True)
device = urlparse(args.device)
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create NETCONF provider
provider = NetconfServiceProvider(address=device.hostname,
port=device.port,
username=device.username,
password=device.password,
protocol=device.scheme)
# create CRUD service
crud = CRUDService()
host_names = xr_shellutil_cfg.HostNames() # create object
config_host_names(host_names) # add object configuration
# update configuration on NETCONF device
crud.update(provider, host_names)
provider.close()
exit()
# End of script
class SanityGnmiCrud(unittest.TestCase):
@classmethod
def setUpClass(self):
self.codec_provider = CodecServiceProvider()
self.codec = CodecService()
self.repo = Repository(get_local_repo_dir())
self.provider = gNMIServiceProvider( self.repo, "127.0.0.1", 50051, "admin", "admin")
self.schema = self.provider.get_session().get_root_schema()
self.crud = CRUDService()
def test_gnmi_crud_all_operations(self):
# Configure interface
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config.name = 'Loopback10'
# Configure BGP
bgp_global_config = openconfig_bgp.Bgp.Global.Config()
bgp_global_config.as_ = 65172
neighbor = openconfig_bgp.Bgp.Neighbors.Neighbor()
neighbor.neighbor_address = '172.16.255.2'
neighbor.config.neighbor_address = '172.16.255.2'
neighbor.config.peer_as = 65172
res = self.crud.create(self.provider, [lo10, bgp_global_config, neighbor])
# Update configuration
lo10.config.description = 'Test'
res = self.crud.update(self.provider, lo10)
self.assertTrue(res)
# Read all
read_list = self.crud.read(self.provider, [openconfig_interfaces.Interfaces(), openconfig_bgp.Bgp()])
# Read config
ifc_filter = openconfig_interfaces.Interfaces.Interface()
ifc_filter.name = 'Loopback10'
bgp_neighbor_filter = openconfig_bgp.Bgp.Neighbors.Neighbor()
bgp_neighbor_filter.neighbor_address = '172.16.255.2'
read_list = self.crud.read_config(self.provider, [ifc_filter, bgp_neighbor_filter])
self.assertIsNotNone(read_list)
self.assertEqual(isinstance(read_list, list), True)
self.assertEqual(len(read_list), 2)
#for entity in read_list:
# print_entity(entity, self.schema)
# Read single container
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config = YFilter.read
ifc_config = self.crud.read(self.provider, lo10)
#print_entity(ifc_config, self.schema)
expected = '''<interface>
<name>Loopback10</name>
<config>
<name>Loopback10</name>
<description>Test</description>
</config>
</interface>
'''
self.assertEqual( entity_to_string(ifc_config, self.schema), expected)
# Read single leaf
ifcs = openconfig_interfaces.Interfaces()
lo10 = openconfig_interfaces.Interfaces.Interface()
lo10.name = 'Loopback10'
lo10.config.description = YFilter.read
ifcs.interface.append(lo10)
read_descr = self.crud.read(self.provider, lo10)
#print_entity(read_descr, self.schema)
expected = '''<interface>
<name>Loopback10</name>
<config>
<description>Test</description>
</config>
</interface>
'''
self.assertEqual( entity_to_string(read_descr, self.schema), expected)
# Delete configuration
ifc = openconfig_interfaces.Interfaces.Interface()
ifc.name = 'Loopback10'
bgp = openconfig_bgp.Bgp()
res = self.crud.delete(self.provider, [ifc, bgp])
from ydk.providers import NetconfServiceProvider
from ydk.services import CRUDService
from ydk.models.cisco_nx_os import Cisco_NX_OS_device
from ydk.filters import YFilter
def setup_logger():
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - " \
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
setup_logger()
crud = CRUDService()
ncc = NetconfServiceProvider(address='93180-EX-1',
username='******',
password='******')
s = Cisco_NX_OS_device.System()
l = s.bd_items.bd_items.BDList()
l.fabencap = 'vlan-123'
l.yfilter = YFilter.delete
s.bd_items.bd_items.bd_list.append(l)
crud.update(ncc, s)
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
@unittest.skip('DELETE object for leaf-list')
def test_delete_object_on_leaflist(self):
# create runner with a leaf and a leaflist
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring = [str(i) for i in range(5)]
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# user DELETE object to remove leaflist
runner_delete = runner_read
runner_delete.ytypes.built_in_t.llstring = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf one
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
# create runner with a container and a list
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
elem1 = ysanity.Runner.OneList.Ldata()
elem2 = ysanity.Runner.OneList.Ldata()
elem1.number = 1
elem2.name = 'foo'
elem2.number = 1
elem2.name = 'bar'
runner_create.one_list.ldata.extend([elem1, elem2])
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
self.crud.delete(self.ncc, runner_read.one_list.ldata)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class SanityYang(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityYang.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
self.ncc.close()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def test_read_on_ref_class(self):
r_1 = Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2.one = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
def test_read_on_leaf(self):
r_1 = Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2.one.number = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_2.one.number, r_1.one.number)
# this will also read r_2.one.name, not able to read only one of them
r_2 = Runner()
r_2.one.number = 1
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_2.one.number, r_1.one.number)
# no such value, will return empty data
r_2 = Runner()
r_2.one.number = 2
r_2 = self.crud.read(self.ncc, r_2)
self.assertNotEqual(r_2.one.number, r_1.one.number)
def test_read_on_ref_enum_class(self):
r_1 = Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.local
self.crud.create(self.ncc, r_1)
r_2 = Runner.Ytypes.BuiltInT()
r_2.enum_value = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
r_2 = Runner.Ytypes.BuiltInT()
r_2.enum_value = YdkEnumTestEnum.local
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# no such value, nothing returned
r_2 = Runner.Ytypes.BuiltInT()
r_2.enum_value = YdkEnumTestEnum.remote
r_2 = self.crud.read(self.ncc, r_2)
self.assertNotEqual(is_equal(r_1, r_2), True)
def test_read_on_ref_list(self):
r_1 = Runner.OneList()
l_1, l_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
l_1.number, l_2.number = 1, 2
r_1.ldata.extend([l_1, l_2])
self.crud.create(self.ncc, r_1)
r_2 = Runner.OneList()
r_2.ldata = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
def test_read_on_list_with_key(self):
r_1 = Runner.OneList()
l_1, l_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
l_1.number, l_2.number = 1, 2
r_1.ldata.extend([l_1, l_2])
self.crud.create(self.ncc, r_1)
r_2 = Runner.OneList()
r_2.ldata.extend([l_1])
r_2 = self.crud.read(self.ncc, r_2)
r_3 = Runner.OneList()
r_3.ldata.extend([l_1])
self.assertEqual(is_equal(r_2, r_3), True)
def test_read_on_leaflist(self):
r_1 = Runner.Ytypes.BuiltInT()
r_1.llstring.extend(['1', '2', '3'])
self.crud.create(self.ncc, r_1)
r_2 = Runner.Ytypes.BuiltInT()
r_2.llstring.extend(['1', '2', '3'])
runner_read = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, runner_read), True)
r_2 = Runner.Ytypes.BuiltInT()
# invalid input, user should use READ()
# or the same data on device
r_2.llstring.extend(['something else'])
runner_read = self.crud.read(self.ncc, r_2)
self.assertNotEqual(is_equal(r_1, runner_read), True)
def test_read_on_identity_ref(self):
r_1 = Runner.Ytypes.BuiltInT()
r_1.identity_ref_value = ChildIdentityIdentity()
self.crud.create(self.ncc, r_1)
r_2 = Runner.Ytypes.BuiltInT()
r_2.identity_ref_value = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
r_2 = Runner.Ytypes.BuiltInT()
r_2.identity_ref_value = ChildIdentityIdentity()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
def test_read_only_config(self):
r_1 = Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2, r_3 = Runner(), Runner()
r_2.one.number, r_3.one.number = READ(), READ()
r_2 = self.crud.read(self.ncc, r_2, only_config=True)
r_3 = self.crud.read(self.ncc, r_3)
# ysanity only have config data, ok to compare
self.assertEqual(is_equal(r_2, r_3), True)
def test_decoder(self):
# send payload to device
runner = Runner()
element = Runner.OneList.Ldata()
element.number = 5
element.name = 'five'
runner.one_list.ldata.append(element)
self.crud.create(self.ncc, runner)
self.crud.read(self.ncc, Runner.OneList.Ldata())
def test_replace_on_leaf(self):
one = Runner.One()
one.number, one.name = 1, 'runner-one-name'
self.crud.create(self.ncc, one)
filter = Runner.One()
filter.number = READ()
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.number, one.number)
# Replace leaf value and verify
one = Runner.One()
one.name = REPLACE('runner_one_name')
one.number = MERGE(2)
self.crud.update(self.ncc, one)
filter = Runner.One()
filter.name = READ()
filter.number = READ()
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.name, 'runner_one_name')
self.assertEqual(r.number, 2)
one = Runner.One()
one.number = REMOVE()
self.crud.update(self.ncc, one)
one.number = CREATE(3)
self.crud.update(self.ncc, one)
r = self.crud.read(self.ncc, Runner.One())
self.assertEqual(r.name, 'runner_one_name')
self.assertEqual(r.number, 3)
def test_replace_on_enum(self):
# Create and verify
btc = Runner.Ytypes.BuiltInT()
btc.enum_value = YdkEnumTestEnum.local
self.crud.create(self.ncc, btc)
filter = Runner.Ytypes.BuiltInT()
filter.enum_value = READ()
r = self.crud.read(self.ncc, filter)
self.assertTrue(is_equal(r, btc))
# Replace and Verify
btr = Runner.Ytypes.BuiltInT()
btr.enum_value = REPLACE(YdkEnumTestEnum.remote)
self.crud.update(self.ncc, btr)
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.enum_value, YdkEnumTestEnum.remote)
def test_create_identity_ref(self):
# Create and Verify
btc = Runner.Ytypes.BuiltInT()
btc.identity_ref_value = CREATE(ChildIdentityIdentity())
self.crud.update(self.ncc, btc)
filter = Runner.Ytypes.BuiltInT()
filter.identity_ref_value = READ()
r = self.crud.read(self.ncc, filter)
self.assertTrue(is_equal(r.identity_ref_value,
ChildIdentityIdentity()))
def test_replace_on_list(self):
one_list = Runner.OneList()
ld1, ld2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
ld1.number, ld2.number = 1, 2
one_list.ldata.extend([ld1, ld2])
self.crud.create(self.ncc, one_list)
filter = Runner.OneList.Ldata()
filter.number = 2
r = self.crud.read(self.ncc, filter)
self.assertTrue(is_equal(r, ld2))
# Merge and Verify
one_merge = Runner.OneList()
ld3 = Runner.OneList.Ldata()
ld3.number = 3
one_merge.ldata.append(ld3)
one_merge.yfilter = MERGE()
self.crud.update(self.ncc, one_merge)
r = self.crud.read(self.ncc, Runner.OneList())
self.assertEqual(len(r.ldata), 3)
# Replace and Verify
replace = Runner.OneList()
replace.ldata.append(ld3)
replace.yfilter = REPLACE()
self.crud.update(self.ncc, replace)
r = self.crud.read(self.ncc, Runner.OneList())
self.assertEqual(len(r.ldata), 1)
def test_replace_on_container(self):
one = Runner.One()
one.number, one.name = 1, 'runner-one-name'
self.crud.create(self.ncc, one)
filter = Runner.One()
r = self.crud.read(self.ncc, filter)
self.assertEqual(one.number, r.number)
# Replace container value and verify
one.yfilter = REPLACE()
one.name = 'runner_one_name'
one.number = 2
self.crud.update(self.ncc, one)
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.name, 'runner_one_name')
self.assertEqual(r.number, 2)
one.yfilter = REMOVE()
self.crud.update(self.ncc, one)
r = self.crud.read(self.ncc, Runner.One())
self.assertIsNone(r.name)
self.assertIsNone(r.number)
device = urllib.parse.urlparse(args.device)
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create NETCONF provider
provider = NetconfServiceProvider(address=device.hostname,
port=device.port,
username=device.username,
password=device.password,
protocol=device.scheme)
# create CRUD service
crud = CRUDService()
# BGP configuration filter
router = xr_um_router_bgp_cfg.Router()
bgp_peer_remove_filter(router, args.local_as, args.peer_address)
# update configuration on NETCONF device
crud.update(provider, router)
exit()
# End of script
class YDKTarget:
def __init__(self,
host=None,
username=None,
password=None,
port=NETCONF_PORT):
self._address = host
self._port = port
self._username = username
self._password = password
self._provider = None
self._crudService = CRUDService()
# Just in case an error occurs somewhere in the YDK API. It will mess with
# Ansible, but at least there's a chance of seeing what happened
@staticmethod
def _setupLogging():
logger = logging.getLogger('ydk')
# logger.setLevel(logging.DEBUG)
logger.setLevel(logging.ERROR)
handler = logging.StreamHandler()
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
def checkParams(self):
if self._address is None:
return YDKTargetParamError(True, 'missing host parameter')
if self._username is None:
return YDKTargetParamError(True, 'missing username parameter')
if self._password is None:
return YDKTargetParamError(True, 'missing password parameter')
return YDKTargetParamError(False, 'ok')
def info(self):
return [self._address, self._port, self._username, self._password]
def connect(self):
self._setupLogging()
self._provider = NetconfServiceProvider(address=self._address,
port=self._port,
username=self._username,
password=self._password)
def close(self):
self._provider.close()
def create(self, config):
return self._crudService.create(self._provider, config)
def read(self, filterSpec):
return self._crudService.read(self._provider, filterSpec)
def update(self, config):
return self._crudService.update(self._provider, config)
def delete(self, config):
return self._crudService.delete(self._provider, config)
def getCapabilities(self):
return self._provider._get_capabilities()
def validateModelCapability(self, modelName):
pattern = re.compile(modelName + '\?')
capabilities = self._provider._get_capabilities()
for capability in capabilities:
if pattern.match(capability):
return True
return False
args = parser.parse_args()
device = urlparse(args.device)
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create NETCONF provider
provider = NetconfServiceProvider(address=device.hostname,
port=device.port,
username=device.username,
password=device.password,
protocol=device.scheme)
# create CRUD service
crud = CRUDService()
host_names = xr_shellutil_cfg.HostNames() # create object
config_host_names(host_names) # add object configuration
# update configuration on NETCONF device
crud.update(provider, host_names)
exit()
# End of script
class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(
"127.0.0.1",
"admin",
"admin",
12022,
)
self.crud = CRUDService()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def test_delete_on_list_with_identitykey(self):
a1 = Runner.OneList.IdentityList()
a1.config.id = ChildIdentity()
a1.id_ref = a1.config.id
self.crud.create(self.ncc, a1)
k = Runner.OneList.IdentityList()
k.config.id = ChildIdentity()
k.id_ref = k.config.id
k.yfilter = YFilter.delete
self.crud.update(self.ncc, k)
runner_read = self.crud.read(self.ncc, Runner())
self.assertIsNone(runner_read)
def test_iden_list(self):
# CREATE
il = Runner.OneList.IdentityList()
il.config.id = ChildIdentity()
il.id_ref = ChildIdentity()
self.crud.create(self.ncc, il)
# READ & VALIDATE
runner_filter = Runner()
read_one = self.crud.read(self.ncc, runner_filter.one_list)
self.assertIsNotNone(read_one)
read_il = read_one.identity_list.get(ChildIdentity().to_string())
self.assertIsNotNone(read_il)
read_il.parent = None
self.assertEqual(read_il, il)
# DELETE & VALIDATE
self.crud.delete(self.ncc, il)
runner_read = self.crud.read(self.ncc, Runner())
self.assertIsNone(runner_read)
def test_crud_delete_container(self):
# Build loopback configuration
address = Native.Interface.Loopback.Ipv4.Address()
address.ip = "2.2.2.2"
address.netmask = "255.255.255.255"
loopback = Native.Interface.Loopback()
loopback.name = 2222
loopback.ipv4.address.append(address)
native = Native()
native.interface.loopback.append(loopback)
crud = CRUDService()
result = crud.create(self.ncc, native)
self.assertTrue(result)
# Read ipv4 configuration
native = Native()
loopback = Native.Interface.Loopback()
loopback.name = 2222
native.interface.loopback.append(loopback)
ipv4_config = crud.read(self.ncc, loopback.ipv4)
self.assertIsNotNone(ipv4_config)
self.assertEqual(ipv4_config.address['2.2.2.2'].netmask, "255.255.255.255")
# Remove ipv4 configuration
native = Native()
loopback = Native.Interface.Loopback()
loopback.name = 2222
native.interface.loopback.append(loopback)
result = crud.delete(self.ncc, loopback.ipv4)
self.assertTrue(result)
# Delete configuration
native = Native()
result = crud.delete(self.ncc, native)
self.assertEqual(result, True)
def test_netconf_delete_container(self):
# Build loopback configuration
address = Native.Interface.Loopback.Ipv4.Address()
address.ip = "2.2.2.2"
address.netmask = "255.255.255.255"
loopback = Native.Interface.Loopback()
loopback.name = 2222
loopback.ipv4.address.append(address)
native = Native()
native.interface.loopback.append(loopback)
ns = NetconfService()
result = ns.edit_config(self.ncc, Datastore.candidate, native)
self.assertTrue(result)
# Read ipv4 configuration
native = Native()
loopback = Native.Interface.Loopback()
loopback.name = 2222
native.interface.loopback.append(loopback)
ipv4_config = ns.get_config(self.ncc, Datastore.candidate, loopback.ipv4)
self.assertIsNotNone(ipv4_config)
self.assertEqual(ipv4_config.address['2.2.2.2'].netmask, "255.255.255.255")
# Delete configuration
result = ns.discard_changes(self.ncc)
self.assertEqual(result, True)
class SanityYang(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityYang.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def test_one_level_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.one.number, r_1.one.name = 10, 'runner/one/name'
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_two_level_pos(self):
# READ
r_1 = Runner()
r_1.two.number, r_1.two.name, r_1.two.sub1.number = 2, 'runner:two:name', 21
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.two.number, r_1.two.name, r_1.two.sub1.number = 20, 'runner/two/name', 210
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_three_level_pos(self):
# READ
r_1 = Runner()
r_1.three.number, r_1.three.name, \
r_1.three.sub1.number, r_1.three.sub1.sub2.number = 3, 'runner:three:name', 31, 311
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.three.number, r_1.three.name, \
r_1.three.sub1.number, r_1.three.sub1.sub2.number = 30, 'runner/three/name', 310, 3110
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_onelist_neg_dupkey(self):
# netsim/enxr not complaining
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_2.name = 'foo'
e_2.number = 1
e_2.name = 'bar'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
def test_onelist_neg_update_key_nonexist(self):
# will create a nonexist elem
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
r_1.one_list.ldata.extend([e_1])
self.crud.create(self.ncc, r_1)
r_1.one_list.ldata[0].number = 2
r_1.one_list.ldata[0].name = '2'
r_1.one_list.ldata[0].yfilter = DELETE()
# assuming update on nonexist key will raise Exception
with self.assertRaises(Exception):
self.crud.update(self.ncc, r_1.one_list.ldata[0])
def test_onelsit_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
e_2.number = 2
e_2.name = 'runner:onelist:ldata[' + str(e_2.number) + ']:name'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
e_2.number = 2
e_2.name = 'runner:onelist:ldata[' + str(e_2.number) + ']:name'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_twolist_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.TwoList.Ldata(), Runner.TwoList.Ldata()
e_11, e_12 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:name'
e_11.number = 211
e_11.name = 'runner:twolist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
e_12.number = 212
e_12.name = 'runner:twolist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:name'
e_21.number = 221
e_21.name = 'runner:twolist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
e_22.number = 222
e_22.name = 'runner:twolist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.TwoList.Ldata(), Runner.TwoList.Ldata()
e_11, e_12 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner/twolist/ldata[' + str(e_1.number) + ']/name'
e_11.number = 211
e_11.name = 'runner/twolist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/name'
e_12.number = 212
e_12.name = 'runner/twolist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner/twolist/ldata[' + str(e_2.number) + ']/name'
e_21.number = 221
e_21.name = 'runner/twolist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/name'
e_22.number = 222
e_22.name = 'runner/twolist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_threelist_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1 = Runner.ThreeList.Ldata()
e_1.number = 31
e_1.name = 'runner:threelist:ldata[' + str(e_1.number) + ']:name'
e_2 = Runner.ThreeList.Ldata()
e_2.number = 32
e_2.name = 'runner:threelist:ldata[' + str(e_2.number) + ']:name'
e_11 = Runner.ThreeList.Ldata.Subl1()
e_12 = Runner.ThreeList.Ldata.Subl1()
e_11.number = 311
e_11.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
e_12.number = 312
e_12.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
e_111 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_112 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_111.number = 3111
e_111.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:subsubl1[' + str(
e_111.number) + ']:name'
e_112.number = 3112
e_112.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:subsubl1[' + str(
e_112.number) + ']:name'
e_11.sub_subl1.extend([e_111, e_112])
e_121 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_122 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_121.number = 3121
e_121.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:subsubl1[' + str(
e_121.number) + ']:name'
e_122.number = 3122
e_121.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:subsubl1[' + str(
e_122.number) + ']:name'
e_12.sub_subl1.extend([e_121, e_122])
e_1.subl1.extend([e_11, e_12])
e_21 = Runner.ThreeList.Ldata.Subl1()
e_22 = Runner.ThreeList.Ldata.Subl1()
e_21.number = 321
e_21.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
e_22.number = 322
e_22.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
e_211 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_212 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_211.number = 3211
e_211.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:subsubl1[' + str(
e_211.number) + ']:name'
e_212.number = 3212
e_212.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:subsubl1[' + str(
e_212.number) + ']:name'
e_21.sub_subl1.extend([e_211, e_212])
e_221 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_222 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_221.number = 3221
e_221.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:subsubl1[' + str(
e_221.number) + ']:name'
e_222.number = 3222
e_222.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:subsubl1[' + str(
e_222.number) + ']:name'
e_22.sub_subl1.extend([e_221, e_222])
e_2.subl1.extend([e_21, e_22])
r_1.three_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DEEPCOPY
r_1_copy = copy.deepcopy(r_1)
self.assertEqual(is_equal(r_1_copy, r_1), True)
self.crud.create(self.ncc, r_1_copy)
r_2_copy = self.crud.read(self.ncc, Runner())
self.assertEqual(is_equal(r_2_copy, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.ThreeList.Ldata()
e_1.number = 31
e_1.name = 'runner/threelist/ldata[' + str(e_1.number) + ']/name'
e_2 = Runner.ThreeList.Ldata()
e_2.number = 32
e_2.name = 'runner/threelist/ldata[' + str(e_2.number) + ']/name'
e_11 = Runner.ThreeList.Ldata.Subl1()
e_12 = Runner.ThreeList.Ldata.Subl1()
e_11.number = 311
e_11.name = 'runner/threelistldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/name'
e_12.number = 312
e_12.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/name'
e_111 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_112 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_111.number = 3111
e_111.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/subsubl1[' + str(
e_111.number) + ']/name'
e_112.number = 3112
e_112.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/subsubl1[' + str(
e_112.number) + ']/name'
e_11.sub_subl1.extend([e_111, e_112])
e_121 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_122 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_121.number = 3121
e_121.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/subsubl1[' + str(
e_121.number) + ']/name'
e_122.number = 3122
e_121.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/subsubl1[' + str(
e_122.number) + ']/name'
e_12.sub_subl1.extend([e_121, e_122])
e_1.subl1.extend([e_11, e_12])
e_21 = Runner.ThreeList.Ldata.Subl1()
e_22 = Runner.ThreeList.Ldata.Subl1()
e_21.number = 321
e_21.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/name'
e_22.number = 322
e_22.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/name'
e_211 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_212 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_211.number = 3211
e_211.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/subsubl1[' + str(
e_211.number) + ']/name'
e_212.number = 3212
e_212.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/subsubl1[' + str(
e_212.number) + ']/name'
e_21.sub_subl1.extend([e_211, e_212])
e_221 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_222 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_221.number = 3221
e_221.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/subsubl1[' + str(
e_221.number) + ']/name'
e_222.number = 3222
e_222.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/subsubl1[' + str(
e_222.number) + ']/name'
e_22.sub_subl1.extend([e_221, e_222])
e_2.subl1.extend([e_21, e_22])
r_1.three_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_InbtwList_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner:inbtwlist:[' + str(e_1.number) + ']:name'
e_1.subc.number = 111
e_1.subc.name = 'runner:inbtwlist:[' + str(e_1.number) + ']:subc:name'
e_2.number = 12
e_2.name = 'runner:inbtwlist:[' + str(e_2.number) + ']:name'
e_2.subc.number = 121
e_2.subc.name = 'runner:inbtwlist:[' + str(e_2.number) + ']:name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner:inbtwlist:[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_11.number) + ']:name'
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner:inbtwlist:[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_12.number) + ']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner:inbtwlist:[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_21.number) + ']:name'
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner:inbtwlist:[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_22.number) + ']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner/inbtwlist/[' + str(e_1.number) + ']/name'
e_1.subc.number = 111
e_1.subc.name = 'runnerinbtwlist/[' + str(e_1.number) + ']/subc/name'
e_2.number = 12
e_2.name = 'runner/inbtwlist/[' + str(e_2.number) + ']/name'
e_2.subc.number = 121
e_2.subc.name = 'runner/inbtwlist/[' + str(e_2.number) + ']/name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner/inbtwlist/[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_11.number) + ']/name'
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner/inbtwlist/[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_12.number) + ']/name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner/inbtwlist/[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_21.number) + ']/name'
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner/inbtwlist/[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_22.number) + ']/name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_leafref_simple_pos(self):
# change ref and original data together
# READ
r_1, r_2 = Runner(), Runner()
r_1.ytypes.built_in_t.number8 = 100
r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.ytypes.built_in_t.number8 = 110
r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_leafref_pos(self):
# rfc: refer to leaf
# 1.already exists
# 2.has default value
# create leafs will be referred to
# CREATE
r_1, r_2 = Runner(), Runner()
r_1.one.name = 'runner:one:name'
r_1.two.sub1.number = 21
r_1.three.sub1.sub2.number = 311
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_2.number = 21
e_1.name = 'runner:inbtwlist[' + str(e_1.number) + ']:name'
e_2.name = 'runner:inbtwlist[' + str(e_2.number) + ']:name'
e_1.subc.number = 111
e_2.subc.number = 121
e_1.subc.name = 'runner:inbtwlist[' + str(e_1.number) + ']:subc:name'
e_2.subc.name = 'runner:inbtwlist[' + str(e_2.number) + ']:subc:name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_12.number = 112
e_11.name = 'runner:inbtwlist[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_11.number) + ']:name'
e_12.name = 'runner:inbtwlist[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_12.number) + ']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 311
e_22.number = 122
e_21.name = 'runner:inbtwlist[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_21.number) + ']:name'
e_22.name = 'runner:inbtwlist[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_22.number) + ']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
r_1.leaf_ref.ref_one_name = r_1.one.name
r_1.leaf_ref.ref_two_sub1_number = r_1.two.sub1.number
r_1.leaf_ref.ref_three_sub1_sub2_number = r_1.three.sub1.sub2.number
r_1.leaf_ref.ref_inbtw = e_21.name
r_1.leaf_ref.one.name = 'runner:leaf-ref:one:name'
r_1.leaf_ref.one.two.self_ref_one_name = r_1.leaf_ref.ref_one_name
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_1.one.name, r_1.leaf_ref.ref_one_name)
self.assertEqual(r_1.two.sub1.number, r_1.leaf_ref.ref_two_sub1_number)
self.assertEqual(r_1.three.sub1.sub2.number,
r_1.leaf_ref.ref_three_sub1_sub2_number)
self.assertEqual(r_1.inbtw_list.ldata[1].subc.subc_subl1[0].name,
r_1.leaf_ref.ref_inbtw)
self.assertEqual(r_1.leaf_ref.ref_one_name,
r_1.leaf_ref.one.two.self_ref_one_name)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.one.name = 'runner/one/name'
r_1.two.sub1.number = 21
r_1.three.sub1.sub2.number = 311
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_2.number = 21
e_1.name = 'runner/inbtwlist[' + str(e_1.number) + ']/name'
e_2.name = 'runner/inbtwlist[' + str(e_2.number) + ']/name'
e_1.subc.number = 111
e_2.subc.number = 121
e_1.subc.name = 'runner/inbtwlist[' + str(e_1.number) + ']/subc/name'
e_2.subc.name = 'runner/inbtwlist[' + str(e_2.number) + ']/subc/name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_12.number = 112
e_11.name = 'runner/inbtwlist[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_11.number) + ']/name'
e_12.name = 'runner/inbtwlist[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_12.number) + ']/name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 311
e_22.number = 122
e_21.name = 'runner/inbtwlist[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_21.number) + ']/name'
e_22.name = 'runner/inbtwlist[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_22.number) + ']/name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
r_1.leaf_ref.ref_one_name = r_1.one.name
r_1.leaf_ref.ref_two_sub1_number = r_1.two.sub1.number
r_1.leaf_ref.ref_three_sub1_sub2_number = r_1.three.sub1.sub2.number
r_1.leaf_ref.ref_inbtw = e_21.name
r_1.leaf_ref.one.name = 'runner/leaf-ref/one/name'
r_1.leaf_ref.one.two.self_ref_one_name = r_1.leaf_ref.ref_one_name
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_1.one.name, r_1.leaf_ref.ref_one_name)
self.assertEqual(r_1.two.sub1.number, r_1.leaf_ref.ref_two_sub1_number)
self.assertEqual(r_1.three.sub1.sub2.number,
r_1.leaf_ref.ref_three_sub1_sub2_number)
self.assertEqual(r_1.inbtw_list.ldata[1].subc.subc_subl1[0].name,
r_1.leaf_ref.ref_inbtw)
self.assertEqual(r_1.leaf_ref.ref_one_name,
r_1.leaf_ref.one.two.self_ref_one_name)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_aug_one_pos(self):
# CREATE
r_1, r_2 = Runner(), Runner()
r_1.one.one_aug.number = 1
r_1.one.one_aug.name = r_1.one.one_aug._common_path
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.one.one_aug.number = 10
r_1.one.one_aug.name = r_1.one.one_aug._common_path.replace(':', '/')
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_aug_onelist_pos(self):
# CREATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.OneList.OneAugList.Ldata()
e_2 = Runner.OneList.OneAugList.Ldata()
e_1.number = 1
e_1.name = e_1._common_path
e_2.number = 2
e_2.name = e_2._common_path
r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
r_1.one_list.one_aug_list.enabled = True
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.OneList.OneAugList.Ldata()
e_2 = Runner.OneList.OneAugList.Ldata()
e_1.number = 1
e_1.name = e_1._common_path.replace(':', '/')
e_2.number = 2
e_2.name = e_2._common_path.replace(':', '/')
r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
r_1.one_list.one_aug_list.enabled = True
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_2._has_data(), False)
def test_parent_empty(self):
runner = Runner()
runner.ytypes.enabled = Empty()
runner.ytypes.built_in_t.emptee = Empty()
self.crud.create(self.ncc, runner)
runner_read = self.crud.read(self.ncc, Runner())
self.assertEqual(is_equal(runner_read, runner), True)
def create_service(request, nc_provider):
# create CRUD service
crud = CRUDService()
# create codec provider
codec_provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
interface_name = request['interface-name']
# create ifmgr obj
if_cfg = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration()
if_cfg.active = "act"
if_cfg.interface_name = interface_name
if_cfg.interface_mode_non_physical = xr_ifmgr_cfg.InterfaceModeEnum.l2_transport
# creat ethernet service Encapsulation obj
if_cfg.ethernet_service.encapsulation = if_cfg.ethernet_service.Encapsulation(
)
encap_type = xr_eth_infra_dt.Match.match_dot1q
encap_value = xr_eth_infra_dt.Vlan = int(request['vlan-id'])
if_cfg.ethernet_service.encapsulation.outer_tag_type = encap_type
if_cfg.ethernet_service.encapsulation.outer_range1_low = encap_value
if_cfg.ethernet_service.rewrite = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.EthernetService.Rewrite(
)
rewrite_type = xr_eth_infra_dt.Rewrite.pop1
if_cfg.ethernet_service.rewrite.rewrite_type = rewrite_type
# create localtraffic obj
local_traffic_def_encap = if_cfg.ethernet_service.LocalTrafficDefaultEncapsulation(
)
if_cfg.ethernet_service.local_traffic_default_encapsulation = local_traffic_def_encap
if_cfg.ethernet_service.local_traffic_default_encapsulation = if_cfg.ethernet_service.encapsulation
# create the interface configurations add the if_cfg to it
if_cfgs = xr_ifmgr_cfg.InterfaceConfigurations()
if_cfgs.interface_configuration.append(if_cfg)
if request['delete-config'] == 'off':
crud.create(nc_provider, if_cfgs)
elif request['delete-config'] == 'on':
crud.delete(nc_provider, if_cfg)
# create the l2vpn object, database and pw classes
# set enable as "Empty" type
l2vpn_cfg = xr_l2vpn_cfg.L2vpn()
l2vpn_cfg.enable = Empty()
l2vpn_cfg.database = xr_l2vpn_cfg.L2vpn.Database()
l2vpn_cfg.database.pseudowire_classes = l2vpn_cfg.Database.PseudowireClasses(
)
test_class = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass(
)
test_class.name = "ELINE-PW"
test_class.enable = Empty()
test_class.mpls_encapsulation = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass(
).MplsEncapsulation()
test_class.mpls_encapsulation.enable = Empty()
test_class.mpls_encapsulation.control_word = xr_l2vpn_cfg.ControlWord.enable
flow_label = xr_l2vpn_cfg.FlowLabelLoadBalance()
# flow_label = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass.MplsEncapsulation.LoadBalanceGroup.FlowLabelLoadBalance()
test_class.mpls_encapsulation.load_balance_group = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass.MplsEncapsulation.LoadBalanceGroup(
)
test_class.mpls_encapsulation.load_balance_group.flow_label_load_balance.flow_label = flow_label.both
l2vpn_cfg.database.pseudowire_classes.pseudowire_class.append(test_class)
l2vpn_cfg.database.xconnect_groups = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups(
)
test_group = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup()
test_group.name = "ELINE-SVCS"
l2vpn_cfg.database.xconnect_groups.xconnect_group.append(test_group)
test_group.p2p_xconnects = l2vpn_cfg.Database.XconnectGroups.XconnectGroup.P2pXconnects(
)
test_xconnect = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect(
)
test_xconnect.name = request['vlan-id'] + "-" + request['pw-id']
test_group.p2p_xconnects.p2p_xconnect.append(test_xconnect)
test_xconnect.attachment_circuits = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.AttachmentCircuits(
)
test_ac = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.AttachmentCircuits.AttachmentCircuit(
)
test_ac.name = request['interface-name']
test_ac.enable = Empty()
test_xconnect.attachment_circuits.attachment_circuit.append(test_ac)
test_xconnect.pseudowires = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.Pseudowires(
)
test_pw = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.Pseudowires.Pseudowire(
)
test_pw.pseudowire_id = int(request['pw-id'])
test_neighbor = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.Pseudowires.Pseudowire.Neighbor(
)
test_neighbor.neighbor = request['neighbor-ip']
test_neighbor.class_ = "ELINE-PW"
test_pw.neighbor.append(test_neighbor)
test_xconnect.pseudowires.pseudowire.append(test_pw)
the_xml = codec.encode(codec_provider, l2vpn_cfg)
if request['delete-config'] == 'off':
crud.create(nc_provider, l2vpn_cfg)
elif request['delete-config'] == 'on':
xc_group = l2vpn_cfg.database.xconnect_groups.xconnect_group.get(
"ELINE-SVCS")
xc = xc_group.p2p_xconnects.p2p_xconnect[test_xconnect.name]
xc.yfilter = YFilter.delete
# xc.attachment_circuits.yfilter = YFilter.delete
# xc.pseudowires.yfilter = YFilter.delete
crud.update(nc_provider, xc_group)
return
class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******', password='******', port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
print "\nIn method", self._testMethodName
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def _create_runner(self):
runner = ysanity.Runner()
runner.ytypes = runner.Ytypes()
runner.ytypes.built_in_t = runner.ytypes.BuiltInT()
return runner
# def test_invalids(self):
# runner = self._create_runner()
# runner.ytypes.built_in_t.name = []
# runner.ytypes.built_in_t.u_number8 = -1
# runner.ytypes.built_in_t.enum_value = ''
# self.crud.create(self.ncc, runner)
# with self.assertRaises(YPYDataValidationError):
# self.crud.create(self.ncc, runner)
def test_int8(self):
# Create Runner
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int8_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 8.5
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # invalid object is not equal
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_int16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = 126
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int16_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = {}
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_int32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = 200000
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int32_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = []
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_bits(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bits_value['disable-nagle'] = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = -9223372036854775808
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_int64_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = 9223372036854775808
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_uint8(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_uint8_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = -1
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_uint16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 65535
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_unint16_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 'not an uint'
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_uint32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 5927
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_unint32_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 4294967296
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_decimal64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.deci64 = Decimal64('3.14')
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('Revisit implementation')
def test_uint64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = 18446744073709551615
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('skip till validation in place')
def test_uint64_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = 18446744073709551616
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_string(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = 'name_str'
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# but invalid input is sent to the device
def test_string_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = ['name_str']
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# self.crud.create(self.ncc, runner)
# Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_empty(self):
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = Empty()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# explicit DELETE not support at the moment
# runner1.ytypes.built_in_t.emptee = DELETE()
# self.crud.update(self.ncc, runner1)
# runner2 = self.crud.read(self.ncc, self._create_runner())
# self.assertEqual(runner2.ytypes.built_in_t.emptee, None)
def test_empty_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = 0
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# Read into Runner2
# runner1 = ysanity.Runner()
# self.assertRaises(YPYDataValidationError,
# self.crud.create, self.ncc, runner)
# runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_boolean(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.crud.update(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('boolean type will convert empty string to false')
def test_boolean_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = ''
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, True)
def test_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = YdkEnumTestEnum.NONE
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_enum_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = 'not an enum'
# self.crud.create(self.ncc, runner)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# OLD
# with self.assertRaises(YPYError) as e:
# self.crud.create(self.ncc, runner)
# # Read into Runner2
# runner1 = ysanity.Runner()
# runner1 = self.crud.read(self.ncc, runner1)
# # # Compare runners
# result = is_equal(runner, runner1)
# self.assertEqual(result, False)
def test_union(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion = YdkEnumTestEnum.NONE
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = YdkEnumIntTestEnum.ANY
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_int(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = 2
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_identityref(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
ysanity.ChildIdentity_Identity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# Will only test max-elements. If min-elements is set, then this
# constraint is required for every READ/UPDATE operation. So it will fail all other cases.
def test_leaflist_max_elements(self):
runner = self._create_runner()
runner.ytypes.built_in_t.llstring = [str(i) for i in range(30)]
runner.ytypes.built_in_t.llstring.extend([None for i in range(20)])
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
def test_list_max_elements(self):
runner = self._create_runner()
elems = []
n = 10
for i in range(n):
l = ysanity.Runner.OneList.Ldata()
l.number = i
l.name = str(i)
elems.append(l)
runner.one_list.ldata.extend(elems)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
def test_submodule(self):
subtest = ysanity.SubTest()
subtest.one_aug.name = 'test'
subtest.one_aug.number = 3
res = self.crud.create(self.ncc, subtest)
subtest1 = self.crud.read(self.ncc, ysanity.SubTest())
# Compare runners
result = is_equal(subtest, subtest1)
self.assertEqual(result, True)
def test_identity_from_other_module(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
ysanity_types.YdktestType_Identity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
from ydk.services import CRUDService
from ydk.providers import NetconfServiceProvider
from ydk.models.cisco_ios_xr.Cisco_IOS_XR_ifmgr_cfg import InterfaceConfigurations
if __name__ == "__main__":
# create NETCONF session
provider = NetconfServiceProvider(address="11.1.1.3",
port=830,
username="******",
password="******",
protocol="ssh")
# create CRUD service
crud = CRUDService()
# create interface config object
interfacesDef = InterfaceConfigurations()
# read system time from device
interfaces = crud.read(provider, interfacesDef)
for interfaceConfig in interfaces.interface_configuration:
if interfaceConfig.interface_name == "GigabitEthernet0/0/0/0":
interfaceConfig.description = "Changed from YDK"
break
if crud.update(provider, interfaces):
print "Changed!"
exit()
device = urllib.parse.urlparse(args.device)
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create NETCONF provider
provider = NetconfServiceProvider(address=device.hostname,
port=device.port,
username=device.username,
password=device.password,
protocol=device.scheme)
# create CRUD service
crud = CRUDService()
# interface configuration filter
interfaces = oc_interfaces.Interfaces()
peer_interface_remove_filter(interfaces, args.name)
# update configuration on NETCONF device
crud.update(provider, interfaces)
exit()
# End of script
