class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1', port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
pass
# print "\nIn method", self._testMethodName
# bgp_cfg = bgp.Bgp()
# self.crud.delete(self.ncc, bgp_cfg)
def tearDown(self):
pass
def test_bgp(self):
# Bgp.Global.AfiSafis.AfiSafi.ApplyPolicy is not supported
bgp_cfg = bgp.Bgp()
ipv4_afsf = bgp_cfg.global_.afi_safis.AfiSafi()
ipv4_afsf.afi_safi_name = 'ipv4-unicast'
ipv4_afsf.apply_policy.config.default_export_policy = \
DefaultPolicyTypeEnum.ACCEPT_ROUTE
bgp_cfg.global_.afi_safis.afi_safi.append(ipv4_afsf)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, bgp_cfg)
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):
self.crud.delete(self.ncc, ietf_aug_base_1.Cpython())
self.crud.delete(self.ncc, ietf_aug_base_2.Cpython())
def tearDown(self):
self.crud.delete(self.ncc, ietf_aug_base_1.Cpython())
self.crud.delete(self.ncc, ietf_aug_base_2.Cpython())
def test_aug_base_1(self):
cpython = ietf_aug_base_1.Cpython()
cpython.doc.ydktest_aug_1.aug_one = 'aug one'
cpython.doc.ydktest_aug_2.aug_two = 'aug two'
cpython.doc.ydktest_aug_4.aug_four = 'aug four'
cpython.lib.ydktest_aug_1.ydktest_aug_nested_1.aug_one = 'aug one'
cpython.lib.ydktest_aug_2.ydktest_aug_nested_2.aug_two = 'aug two'
cpython.lib.ydktest_aug_4.ydktest_aug_nested_4.aug_four = 'aug four'
cpython.doc.disutils.four_aug_list.enabled = True
item1 = cpython.doc.disutils.four_aug_list.Ldata()
item2 = cpython.doc.disutils.four_aug_list.Ldata()
item1.name, item1.number = 'one', 1
item2.name, item1.number = 'two', 2
self.crud.create(self.ncc, cpython)
cpython_read = self.crud.read(self.ncc, ietf_aug_base_1.Cpython())
self.assertEqual(is_equal(cpython, cpython_read), True)
def test_aug_base_2(self):
cpython = ietf_aug_base_2.Cpython()
cpython.tools.aug_four = 'aug four'
self.crud.create(self.ncc, cpython)
cpython_read = self.crud.read(self.ncc, ietf_aug_base_2.Cpython())
self.assertEqual(is_equal(cpython, cpython_read), True)
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()
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
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()
# config device with entity a
a = self.getInitEntity()
self.crud.delete(self.ncc, a)
self.crud.create(self.ncc, a)
def setUpClass(self):
self.ncc = NetconfServiceProvider(
address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
a = self.getInitEntity()
self.crud.delete(self.ncc, a)
self.crud.create(self.ncc, a)
def test_keybase_auth(self):
dir_path = os.path.dirname(os.path.realpath(__file__))
private = "%s/ssh_host_rsa_key" % dir_path
public = "%s/ssh_host_rsa_key.pub" % dir_path
provider = NetconfServiceProvider(
address = self.hostname,
username = self.username,
private_key_path = private,
public_key_path = public,
port = self.port)
session = provider.get_session()
self.assertEqual(session is not None, True)
encoding = provider.get_encoding()
self.assertEqual(encoding is not None, True)
capabilities = provider.get_capabilities()
self.assertEqual(capabilities is not None, True)
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):
self.ncc.close()
def setUp(self):
pass
def tearDown(self):
pass
def test_bgp(self):
# Bgp.Global.AfiSafis.AfiSafi.ApplyPolicy is not supported
bgp_cfg = bgp.Bgp()
ipv4_afsf = bgp_cfg.global_.afi_safis.AfiSafi()
ipv4_afsf.afi_safi_name = 'ipv4-unicast'
ipv4_afsf.apply_policy.config.default_export_policy = \
DefaultPolicyTypeEnum.ACCEPT_ROUTE
bgp_cfg.global_.afi_safis.afi_safi.append(ipv4_afsf)
self.assertRaises(YPYModelError,
self.crud.create, self.ncc, bgp_cfg)
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)
# TODO: crud read or READ object?
def test_read_on_ref_class(self):
r_1 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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):
from ydk.models.ydktest.ydktest_sanity import YdkEnumTestEnum
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.LOCAL
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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)
# TODO: crud read or READ object?
def test_read_on_ref_list(self):
r_1 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(), ysanity.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 = ysanity.Runner.OneList()
r_2.ldata = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# crud read
def test_read_on_list_with_key(self):
r_1 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(), ysanity.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 = ysanity.Runner.OneList()
r_2.ldata.extend([l_1])
r_2 = self.crud.read(self.ncc, r_2)
r_3 = ysanity.Runner.OneList()
r_3.ldata.extend([l_1])
self.assertEqual(is_equal(r_2, r_3), True)
# crud read
def test_read_on_leaflist(self):
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.llstring.extend(['1', '2', '3'])
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.Runner.Ytypes.BuiltInT()
r_1.identity_ref_value = ysanity.ChildIdentity_Identity()
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.Runner.Ytypes.BuiltInT()
r_2.identity_ref_value = ysanity.ChildIdentity_Identity()
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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2, r_3 = ysanity.Runner(), ysanity.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 = ysanity.Runner()
element = ysanity.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, ysanity.Runner.OneList.Ldata())
neighbor_group_af.activate = Empty()
neighbor_group_afs = neighbor_group.neighbor_group_afs
neighbor_group_afs.neighbor_group_af.append(neighbor_group_af)
# configure IBGP neighbor
neighbor = four_byte_as.default_vrf.bgp_entity.neighbors.Neighbor()
neighbor.neighbor_address = "172.16.255.2"
neighbor.neighbor_group_add_member = "IBGP"
four_byte_as.default_vrf.bgp_entity.neighbors.neighbor.append(neighbor)
if __name__ == "__main__":
"""Execute main program."""
# create NETCONF provider
provider = NetconfServiceProvider(address="11.1.1.3",
port=830,
username="******",
password="******",
protocol="ssh")
# create CRUD service
crud = CRUDService()
bgp = xr_ipv4_bgp_cfg.Bgp() # create object
config_bgp(bgp) # add object configuration
# create configuration on NETCONF device
crud.create(provider, bgp)
exit()
# End of script
from ydk.services import CRUDService from ydk.providers import NetconfServiceProvider from ydk.models.bgp import bgp provider = NetconfServiceProvider(address=xrv, port=830, username=“cisco”, password=“cisco”, protocol=“ssh") crud = CRUDService() # create CRUD service bgp = bgp.Bgp() # create oc bgp object # set local AS number bgp.global_.config.router-id_ = "1.1.1.1" crud.create(provider, bgp) #create on NETCONF device provider.close()
class SanityNetconf(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
from ydk.providers import NetconfServiceProvider
from ydk.services import NetconfService
if SanityNetconf.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.netconf_service = NetconfService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
from ydk.services import CRUDService
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
pass
def _create_runner(self):
runner = ysanity.Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
return runner
def test_copy_config_invalid_1(self):
try:
from ydk.services import Datastore
op = self.netconf_service.copy_config(self.ncc,
target=None,
source=Datastore.running)
except YPYServiceError as err:
expected_msg = "'target' and 'source' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_copy_config_invalid_2(self):
try:
from ydk.services import Datastore
op = self.netconf_service.copy_config(self.ncc,
target=Datastore.candidate,
source=None)
except YPYServiceError as err:
expected_msg = "'target' and 'source' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_copy_config_invalid_3(self):
try:
op = self.netconf_service.copy_config(self.ncc,
target=None,
source=None)
except YPYServiceError as err:
expected_msg = "'target' and 'source' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_copy_config_invalid_4(self):
try:
from ydk.services import Datastore
op = self.netconf_service.copy_config(self.ncc,
target=Datastore.candidate,
source=Datastore.running,
with_defaults_option=1)
except YPYServiceError as err:
expected_msg = "optional arg 'with_defaults_option' must be of type ietf_netconf_with_defaults.WithDefaultsModeEnum"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_delete_config_invalid(self):
try:
op = self.netconf_service.delete_config(self.ncc, target=None)
except YPYServiceError as err:
expected_msg = "'target' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_edit_config_invalid_1(self):
try:
runner = self._create_runner()
op = self.netconf_service.edit_config(self.ncc, None, runner)
except YPYServiceError as err:
expected_msg = "'target' and 'config' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_edit_config_invalid_2(self):
try:
from ydk.services import Datastore
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate, None)
except YPYServiceError as err:
expected_msg = "'target' and 'config' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_edit_config_invalid_3(self):
try:
op = self.netconf_service.edit_config(self.ncc, None, None)
except YPYServiceError as err:
expected_msg = "'target' and 'config' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_edit_config_invalid_4(self):
try:
from ydk.services import Datastore
runner = self._create_runner()
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate,
runner,
default_operation=1)
except YPYServiceError as err:
expected_msg = "optional arg 'default_operation' must be of type ietf_netconf.EditConfigRpc.Input.DefaultOperationEnum"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_edit_config_invalid_5(self):
try:
from ydk.services import Datastore
runner = self._create_runner()
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate,
runner,
error_option=1)
except YPYServiceError as err:
expected_msg = "optional arg 'error_option' must be of type ietf_netconf.EditConfigRpc.Input.ErrorOptionEnum"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_edit_config_invalid_6(self):
try:
from ydk.services import Datastore
runner = self._create_runner()
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate,
runner,
test_option=1)
except YPYServiceError as err:
expected_msg = "optional arg 'test_option' must be of type ietf_netconf.EditConfigRpc.Input.TestOptionEnum"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_get_config_invalid_1(self):
try:
from ydk.services import Datastore
runner = self._create_runner()
get_filter = ysanity.Runner()
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate, runner)
result = self.netconf_service.get_config(self.ncc, None,
get_filter)
except YPYServiceError as err:
expected_msg = "'source' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_get_config_invalid_2(self):
try:
from ydk.services import Datastore
runner = self._create_runner()
get_filter = ysanity.Runner()
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate, runner)
result = self.netconf_service.get_config(self.ncc,
Datastore.candidate,
get_filter,
with_defaults_option=1)
except YPYServiceError as err:
expected_msg = "optional arg 'with_defaults_option' must be of type ietf_netconf_with_defaults.WithDefaultsModeEnum"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_get_invalid(self):
try:
from ydk.services import Datastore
runner = self._create_runner()
get_filter = ysanity.Runner()
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate, runner)
self.assertEqual(None, op)
op = self.netconf_service.discard_changes(self.ncc)
self.assertEqual(None, op)
op = self.netconf_service.edit_config(self.ncc,
Datastore.candidate, runner)
self.assertEqual(None, op)
op = self.netconf_service.commit(self.ncc)
self.assertEqual(None, op)
result = self.netconf_service.get(self.ncc,
get_filter,
with_defaults_option=1)
self.assertEqual(is_equal(runner, result), True)
except YPYServiceError as err:
expected_msg = "optional arg 'with_defaults_option' must be of type ietf_netconf_with_defaults.WithDefaultsModeEnum"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_lock_invalid(self):
try:
op = self.netconf_service.lock(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'target' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_unlock_invalid(self):
try:
from ydk.services import Datastore
op = self.netconf_service.lock(self.ncc, Datastore.candidate)
op = self.netconf_service.unlock(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'target' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_validate_invalid(self):
try:
op = self.netconf_service.validate(self.ncc)
except YPYServiceError as err:
expected_msg = "'source' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
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 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.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('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 = YdkEnumTest_Enum.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 = YdkEnumTest_Enum.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_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 setUpClass(cls):
cls.ncc = NetconfServiceProvider(cls.hostname, cls.username,
cls.password, cls.port, cls.protocol,
not cls.on_demand, cls.common_cache,
cls.timeout)
cls.netconf_service = NetconfService()
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)
the License. All rights not expressly granted by the License are
reserved. Unless required by applicable law or agreed to separately in
writing, software distributed under the License is distributed on an "AS
IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
or implied.
"""
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="localhost",
port=57779,
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"
print('==============\nNETCONF GET SERVICE\n==============')
netconf_service.read(provider, ydk_obj, only_config)
def netconf_get_config(netconf_service, provider, ydk_obj,
datastore=Datastore.candidate, with_defaults_option=None):
print('==============\nNETCONF GET CONFIG SERVICE\n==============')
netconf_service.get_config(provider, datastore, ydk_obj, with_defaults_option)
{% endif %}{% endspaceless %}
if __name__ == "__main__":
_init_logging()
provider = NetconfServiceProvider(address='{{host}}',
username='******',
password='******',
protocol='ssh',
port={{port}})
{% spaceless %}
{% if service_type == 'crud' %}crud_service = CRUDService()
{% if service == 'create' %}{% for i in ydk_obj_names.split %}
ydk_obj = {{i}}()
crud_create(crud_service, provider, ydk_obj)
{% endfor %}{% endif %}
{% if service == 'update' %}{% for i in ydk_obj_names.split %}
ydk_obj = {{i}}()
crud_update(crud_service, provider, ydk_obj)
{% endfor %}{% endif %}
{% if service == 'delete' %}{% for i in ydk_obj_names.split %}
ydk_obj = {{i}}()
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):
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_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)
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)
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)
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)
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)
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)
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)
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)
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)
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 = ysanity.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 = ysanity.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 = 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_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)
def test_embedded_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.embeded_enum = ysanity.Runner.Ytypes.BuiltInT.EmbededEnumEnum.zero
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(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_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_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 = ysanity.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 = ysanity.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 = ysanity.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 = ysanity.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(ysanity.ChildIdentityIdentity())
runner.ytypes.built_in_t.identity_llist.append(ysanity.ChildChildIdentityIdentity())
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_complex_list(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion_list.append("123:45")
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.ChildIdentityIdentity()
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_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 = ysanity.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 = ysanity.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 = 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.YdktestTypeIdentity()
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)
log.addHandler(ch)
def ietf_run(crud_service, provider):
print '==============\nCRUD SERVICE\n=============='
from ydk.models.ietf import ietf_system
sys_obj = _get_obj_system()
crud_service.delete(provider, ietf_system.System())
crud_service.create(provider, sys_obj)
crud_service.delete(provider, ietf_system.System())
print '\n\n================\nCODEC SERVICE\n================'
crud_service.delete(provider, ietf_system.System())
crud_service.create(provider, _get_decoded_entity())
crud_service.delete(provider, ietf_system.System())
if __name__ == "__main__":
_init_logging()
provider = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
crud_service = CRUDService()
ietf_run(crud_service, provider)
exit()
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()
a = self.getInitEntity()
self.crud.delete(self.ncc, a)
self.crud.create(self.ncc, a)
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
pass
@classmethod
def getInitEntity(self):
""" set and return entity with XML:
<a>
<a1>some value</a1>
<a2>value of a2</a2>
<a3>value of a3</a3>
<b>
<b1>some value</b1>
<b2>value of b2</b2>
<b3>value of b3</b3>
<c/>
<d>
<d1>some value d1</d1>
<d2>value of d2</d2>
<d3>value of d3</d3>
<e>
<e1>some value e1</e1>
<e2>value of e2</e2>
</e>
</d>
</b>
<lst>
<number>1</number>
<value>one</value>
</lst>
<lst>
<number>2</number>
<value>two</value>
</lst>
<lst>
<number>3</number>
<value>three</value>
</lst>
</a>
"""
a = ysanity.A()
a.a1, a.a2, a.a3 = "some value", "value of a2", "value of a3"
a.b.b1, a.b.b2, a.b.b3 = "some value", "value of b2", "value of b3"
a.b.c = a.b.C()
a.b.d.d1, a.b.d.d2, a.b.d.d3 = "some value d1", "value of d2", "value of d3"
a.b.d.e.e1, a.b.d.e.e2 = "some value e1", "value of e2"
l1, l2, l3 = a.Lst(), a.Lst(), a.Lst()
l1.number, l1.value = 1, "one"
l2.number, l2.value = 2, "two"
l3.number, l3.value = 3, "three"
a.lst.extend([l1,l2,l3])
return a
def test_CASE1(self):
a = ysanity.A()
a = self.crud.read(self.ncc, a)
# the whole thing
_a = self.getInitEntity()
self.assertEqual(is_equal(a, _a), True)
def test_CASE2(self):
a = ysanity.A()
a.a1 = "some value"
a = self.crud.read(self.ncc, a)
# the whole thing
_a = self.getInitEntity()
self.assertEqual(is_equal(a, _a), True)
def test_CASE3(self):
a = ysanity.A()
a.a1 = READ()
a = self.crud.read(self.ncc, a)
_a = ysanity.A()
_a.a1 = "some value"
self.assertEqual(is_equal(a, _a), True)
def test_CASE4(self):
a = ysanity.A()
a.b.b1 = "some value"
a = self.crud.read(self.ncc, a)
_a = self.getInitEntity()
_a.lst, _a.a1, _a.a2, _a.a3 = YList(), None, None, None
self.assertEqual(is_equal(a, _a), True)
def test_CASE5(self):
a = ysanity.A()
e = a.b.d.e
e.e1 = "some value e1"
a = self.crud.read(self.ncc, a)
_a = ysanity.A()
_a.b.d.e.e1, _a.b.d.e.e2 = "some value e1", "value of e2"
self.assertEqual(is_equal(a, _a), True)
def test_CASE6(self):
a = ysanity.A()
a.b.c = a.b.C()
a = self.crud.read(self.ncc, a)
_a = ysanity.A()
_a.b.c = _a.b.C()
self.assertEqual(is_equal(a, _a), True)
def test_CASE7(self):
a = ysanity.A()
l1, l2 = a.Lst(), a.Lst()
l1.number, l2.number = 1, 2
a.lst.extend([l1, l2])
a = self.crud.read(self.ncc, a)
_a = ysanity.A()
l1.value, l2.value = "one", "two"
_a.lst.extend([l1, l2])
self.assertEqual(is_equal(a, _a), 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_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)
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)
if __name__ == "__main__":
"""Execute main program."""
parser = argparse.ArgumentParser()
parser.add_argument('-v', "--verbose", help="print debugging messages",
action="store_true")
# parser.add_argument('-n', required=True, help='specify node(s) ; Mandatory', nargs='*')
args = parser.parse_args()
# 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)
connection = NetconfServiceProvider(address="10.92.77.167", port=830, username="******", password='******')
crud = CRUDService()
nativeobject = Cisco_IOS_XE_native.Native()
nativedata = crud.read(connection, nativeobject)
provider = CodecServiceProvider(type="xml")
codec = CodecService()
xmls = codec.encode(provider, nativedata)
print (xmls)
connection.close()
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)
class SanityRpc(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityRpc.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.executor = ExecutorService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
from ydk.services import CRUDService
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
pass
def test_execute_edit_commit_get_rpc(self):
runner = ysanity.Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
edit_rpc = ietf_netconf.EditConfigRpc()
edit_rpc.input.target.candidate = Empty()
edit_rpc.input.config = runner
op = self.executor.execute_rpc(self.ncc, edit_rpc)
self.assertEqual(None, op)
commit_rpc = ietf_netconf.CommitRpc()
op = self.executor.execute_rpc(self.ncc, commit_rpc)
self.assertEqual(None, op)
get_rpc = ietf_netconf.GetRpc()
get_rpc.input.filter = ysanity.Runner()
op = self.executor.execute_rpc(self.ncc, get_rpc)
self.assertNotEqual(None, op)
def test_execute_get_config_rpc(self):
get_config_rpc = ietf_netconf.GetConfigRpc()
get_config_rpc.input.source.candidate = Empty()
get_config_rpc.input.filter = ysanity.Runner()
initial_candidate_data = self.executor.execute_rpc(
self.ncc, get_config_rpc)
runner = ysanity.Runner()
runner.two.number = 2
runner.two.name = 'runner:two:name'
edit_rpc = ietf_netconf.EditConfigRpc()
edit_rpc.input.target.candidate = Empty()
edit_rpc.input.config = runner
op = self.executor.execute_rpc(self.ncc, edit_rpc)
self.assertEqual(None, op)
final_candidate_data = self.executor.execute_rpc(
self.ncc, get_config_rpc)
# self.assertNotEqual(initial_candidate_data, final_candidate_data) #TODO
self.assertNotEqual(None, initial_candidate_data)
self.assertNotEqual(None, final_candidate_data)
def test_execute_validate_rpc(self):
validate_rpc = ietf_netconf.ValidateRpc()
validate_rpc.input.source.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, validate_rpc)
self.assertEqual(None, op)
def test_execute_lock_unlock_rpc(self):
lock_rpc = ietf_netconf.LockRpc()
lock_rpc.input.target.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, lock_rpc)
self.assertEqual(None, op)
unlock_rpc = ietf_netconf.UnlockRpc()
unlock_rpc.input.target.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, unlock_rpc)
self.assertEqual(None, op)
def test_execute_lock_unlock_rpc_fail(self):
lock_rpc = ietf_netconf.LockRpc()
lock_rpc.input.target.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, lock_rpc)
self.assertEqual(None, op)
unlock_rpc = ietf_netconf.UnlockRpc()
unlock_rpc.input.target.running = Empty()
try:
op = self.executor.execute_rpc(self.ncc, unlock_rpc)
except Exception as e:
self.assertIsInstance(e, YPYError)
def test_execute_non_rpc_fail(self):
runner = ysanity.Runner()
try:
self.executor.execute_rpc(self.ncc, runner)
except Exception as e:
self.assertIsInstance(e, YPYError)
self.assertEqual(e.code, YPYErrorCode.INVALID_RPC)
@unittest.skip('TODO: get-schema rpc is not yet supported on netsim')
def test_execute_get_schema(self):
get_schema_rpc = ietf_netconf_monitoring.GetSchemaRpc()
get_schema_rpc.input.identifier = 'ietf-netconf-monitoring'
get_schema_rpc.input.format = ietf_netconf_monitoring.Yang_Identity()
op = self.executor.execute_rpc(self.ncc, get_schema_rpc)
print(op)
from ydk.services import CRUDService
from ydk.providers import NetconfServiceProvider
from ydk.models.cisco_ios_xe import Cisco_IOS_XE_interfaces_oper as xe_interface
import device
ios_xe = device.xe_sandbox()
# create NETCONF provider
provider = NetconfServiceProvider(address=ios_xe.hostname,
port=ios_xe.port,
username=ios_xe.username,
password=ios_xe.password,
protocol=ios_xe.protocol)
# create CRUD service
crud = CRUDService()
interfaces_filter = xe_interface.Interfaces()
interfaces = crud.read(provider, interfaces_filter)
for int_entry in range(interfaces.interface.__len__()):
print("{int} has @IP : {ip}".format(int=interfaces.interface[int_entry].name, ip=interfaces.interface[int_entry].ipv4))
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 SanityExecutor(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityExecutor.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.executor = ExecutorService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
from ydk.services import CRUDService
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
pass
def test_execute_rpc_invalid_1(self):
runner = ysanity.Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
edit_rpc = ietf_netconf.EditConfigRpc()
edit_rpc.input.target.candidate = Empty()
edit_rpc.input.config = runner
try:
op = self.executor.execute_rpc(None, edit_rpc)
except YPYServiceError as err:
expected_msg = "'provider' and 'rpc' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_execute_rpc_invalid_2(self):
try:
op = self.executor.execute_rpc(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'rpc' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_execute_rpc_invalid_3(self):
try:
op = self.executor.execute_rpc(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'rpc' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
port=12022)
self.crud = CRUDService()
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)
def crud_read(obj):
crud = CRUDService()
ncc = NetconfServiceProvider(address='93180-EX-1',
username='******',
password='******')
return crud.read(ncc, obj)
def setUpClass(cls):
cls.ncc = NetconfServiceProvider(cls.hostname, cls.username,
cls.password, cls.port, cls.protocol,
cls.on_demand, cls.common_cache)
cls.crud = CRUDService()
afi_safi.config.enabled = True
peer_group.afi_safis.afi_safi.append(afi_safi)
bgp.peer_groups.peer_group.append(peer_group)
# configure IBGP neighbor
neighbor = bgp.neighbors.Neighbor()
neighbor.neighbor_address = remote_peer
neighbor.config.neighbor_address = remote_peer
neighbor.config.peer_group = peer_group_name
bgp.neighbors.neighbor.append(neighbor)
if __name__ == "__main__":
"""Execute main program."""
# create IOS-XR NETCONF provider
xr_provider = NetconfServiceProvider(address=iosxr_host,
port=netconf_port,
username=username,
password=password,
timeout=10)
# create JunOS NETCONF provider
##junos_provider = NetconfServiceProvider(address=junos_host,
## port=netconf_port,
## username=username,
## password=password,
## timeout=10)
#create an instance of the netconf service
netconf = NetconfService()
# Create an IOSXR instance from the OpenConfig BGP Model
xr_bgp = oc_bgp.Bgp()
# Create an JunOS instance from the OpenConfig BGP Model
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()
bgp = oc_bgp.Bgp() # create object
config_bgp(bgp) # add object configuration
# create configuration on NETCONF device
crud.create(provider, bgp)
provider.close()
exit()
# End of script
from ydk.services import CRUDService
from ydk.providers import NetconfServiceProvider
from ydk.models.ietf import ietf_interfaces as intf
from ydk.models.ietf import iana_if_type as iftype
HOST = '172.20.20.10'
PORT = 830
USER = '******'
PASS = '******'
# create NETCONF provider
provider = NetconfServiceProvider(address=HOST,
port=PORT,
username=USER,
password=PASS)
# create CRUD service
crud = CRUDService()
# interface to delete
to_del = intf.Interfaces.Interface()
# create a new loopback
to_del.name = 'Loopback666'
res = crud.delete(provider, to_del)
provider.close()
class SanityNetconf(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityNetconf.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.netconf_service = NetconfService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
from ydk.services import CRUDService
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
pass
def test_edit_commit_get(self):
runner = ysanity.Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
get_filter = ysanity.Runner()
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate, runner)
self.assertIn('ok', op)
result = self.netconf_service.get_config(self.ncc, Datastore.candidate, get_filter)
self.assertEqual(is_equal(runner, result), True)
op = self.netconf_service.commit(self.ncc)
self.assertIn('ok', op)
result = self.netconf_service.get(self.ncc, get_filter)
self.assertEqual(is_equal(runner, result), True)
def test_copy(self):
op = self.netconf_service.copy_config(self.ncc, target=Datastore.candidate, source=Datastore.running)
self.assertIn('ok', op)
def test_lock_unlock(self):
op = self.netconf_service.lock(self.ncc, Datastore.running)
self.assertIn('ok', op)
op = self.netconf_service.unlock(self.ncc, Datastore.running)
self.assertIn('ok', op)
def test_lock_unlock_fail(self):
op = self.netconf_service.lock(self.ncc, Datastore.candidate)
self.assertIn('ok', op)
try:
op = self.netconf_service.unlock(self.ncc, Datastore.running)
except Exception as e:
self.assertIsInstance(e, YPYError)
def test_validate(self):
op = self.netconf_service.validate(self.ncc, source=Datastore.candidate)
self.assertIn('ok', op)
runner = ysanity.Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
op = self.netconf_service.validate(self.ncc, config=runner)
self.assertIn('ok', op)
def test_validate_fail(self):
runner = ysanity.Runner()
runner.one.number = 1
runner.one.name = 2
try:
self.netconf_service.validate(self.ncc, config=runner)
except Exception as e:
self.assertIsInstance(e, YPYModelError)
def test_commit_discard(self):
runner = ysanity.Runner()
runner.two.number = 2
runner.two.name = 'runner:two:name'
get_filter = ysanity.Runner()
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate, runner)
self.assertIn('ok', op)
op = self.netconf_service.discard_changes(self.ncc)
self.assertIn('ok', op)
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate, runner)
self.assertIn('ok', op)
op = self.netconf_service.commit(self.ncc)
self.assertIn('ok', op)
result = self.netconf_service.get(self.ncc, get_filter)
self.assertEqual(is_equal(runner, result), True)
def test_copy_config(self):
op = self.netconf_service.copy_config(self.ncc, Datastore.candidate, Datastore.running)
self.assertIn('ok', op)
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)
# TODO: crud read or READ object?
def test_read_on_ref_class(self):
r_1 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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):
from ydk.models.ydktest.ydktest_sanity import YdkEnumTestEnum
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.LOCAL
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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)
# TODO: crud read or READ object?
def test_read_on_ref_list(self):
r_1 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(
), ysanity.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 = ysanity.Runner.OneList()
r_2.ldata = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# crud read
def test_read_on_list_with_key(self):
r_1 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(
), ysanity.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 = ysanity.Runner.OneList()
r_2.ldata.extend([l_1])
r_2 = self.crud.read(self.ncc, r_2)
r_3 = ysanity.Runner.OneList()
r_3.ldata.extend([l_1])
self.assertEqual(is_equal(r_2, r_3), True)
# crud read
def test_read_on_leaflist(self):
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.llstring.extend(['1', '2', '3'])
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.Runner.Ytypes.BuiltInT()
r_1.identity_ref_value = ysanity.ChildIdentity_Identity()
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.Runner.Ytypes.BuiltInT()
r_2.identity_ref_value = ysanity.ChildIdentity_Identity()
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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2, r_3 = ysanity.Runner(), ysanity.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 = ysanity.Runner()
element = ysanity.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, ysanity.Runner.OneList.Ldata())
class SanityRpc(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1', username='******', password='******', protocol='ssh', port=12022)
self.executor = ExecutorService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
from ydk.services import CRUDService
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
pass
def test_execute_edit_commit_get_rpc(self):
runner = ysanity.Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
edit_rpc = ietf_netconf.EditConfigRpc()
edit_rpc.input.target.candidate = Empty()
edit_rpc.input.config = runner
op = self.executor.execute_rpc(self.ncc, edit_rpc)
self.assertIn('ok', op)
commit_rpc = ietf_netconf.CommitRpc()
op = self.executor.execute_rpc(self.ncc, commit_rpc)
self.assertIn('ok', op)
get_rpc = ietf_netconf.GetRpc()
get_rpc.input.filter = ysanity.Runner()
op = self.executor.execute_rpc(self.ncc, get_rpc)
self.assertIn(runner.one.name, op)
def test_execute_get_config_rpc(self):
get_config_rpc = ietf_netconf.GetConfigRpc()
get_config_rpc.input.source.candidate = Empty()
initial_candidate_data = self.executor.execute_rpc(self.ncc, get_config_rpc)
runner = ysanity.Runner()
runner.two.number = 2
runner.two.name = 'runner:two:name'
edit_rpc = ietf_netconf.EditConfigRpc()
edit_rpc.input.target.candidate = Empty()
edit_rpc.input.config = runner
op = self.executor.execute_rpc(self.ncc, edit_rpc)
self.assertIn('ok', op)
final_candidate_data = self.executor.execute_rpc(self.ncc, get_config_rpc)
self.assertNotEqual(initial_candidate_data, final_candidate_data)
self.assertNotIn(runner.two.name, initial_candidate_data)
self.assertIn(runner.two.name, final_candidate_data)
def test_execute_validate_rpc(self):
validate_rpc = ietf_netconf.ValidateRpc()
validate_rpc.input.source.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, validate_rpc)
self.assertIn('ok', op)
def test_execute_lock_unlock_rpc(self):
lock_rpc = ietf_netconf.LockRpc()
lock_rpc.input.target.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, lock_rpc)
self.assertIn('ok', op)
unlock_rpc = ietf_netconf.UnlockRpc()
unlock_rpc.input.target.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, unlock_rpc)
self.assertIn('ok', op)
def test_execute_lock_unlock_rpc_fail(self):
lock_rpc = ietf_netconf.LockRpc()
lock_rpc.input.target.candidate = Empty()
op = self.executor.execute_rpc(self.ncc, lock_rpc)
self.assertIn('ok', op)
unlock_rpc = ietf_netconf.UnlockRpc()
unlock_rpc.input.target.running = Empty()
try:
op = self.executor.execute_rpc(self.ncc, unlock_rpc)
except Exception as e:
self.assertIsInstance(e, YPYError)
def test_execute_non_rpc_fail(self):
runner = ysanity.Runner()
try:
self.executor.execute_rpc(self.ncc, runner)
except Exception as e:
self.assertIsInstance(e, YPYError)
self.assertEqual(e.error_code, YPYErrorCode.INVALID_RPC)
'''TODO: get-schema rpc is not yet supported on netsim
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1', port=12022)
self.crud = CRUDService()
class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1', port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
print "\nIn method", self._testMethodName
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
# changed to type int16
def test_int8(self):
# Create Runner
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 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)
# changed to type int32
def test_int16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = 20000
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)
# changed to type int64
def test_int32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = -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)
# changed to type uint8
def test_int64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = -9223372036854775808
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# changed to type uint16
def test_uint8(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = 256
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)
# changed to type uint32
def test_uint16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 65536
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)
# changed to type uint64
def test_uint32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 4294967296
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)
# changed to type string
def test_decimal64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.deci64 = 'string'
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)
# changed to tye decimal64
def test_leafref(self):
runner = self._create_runner()
runner.ytypes.built_in_t.leaf_ref = 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)
# changed to type empty
def test_string(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = 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)
# changed to type YdkEnumTestEnum
def test_boolean(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_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)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.assertRaises(YPYDataValidationError,
self.crud.update, self.ncc, runner)
# max val changed to 7
def test_leaflist_max_elements(self):
runner = self._create_runner()
runner.ytypes.built_in_t.llstring = [str(i) for i in range(8)]
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# not supported leaf
def test_not_supported_leaf(self):
runner = self._create_runner()
runner.not_supported_1.not_supported_leaf = 'leaf value'
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# not supported container
def test_not_supported_container(self):
runner = self._create_runner()
runner.not_supported_1.not_supported_1_2.some_leaf = 'some leaf'
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
# not supported list
def test_not_supported_list(self):
runner = self._create_runner()
elems = []
for i in range(5):
elems.append(runner.NotSupported2())
runner.not_supported_2.extend(elems)
self.assertRaises(YPYDataValidationError,
self.crud.create, self.ncc, runner)
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):
self.ncc.close()
def setUp(self):
pass
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
# changed to type int16
def test_int8(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 126
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type int32
def test_int16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = 20000
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type int64
def test_int32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = -9223372036854775808
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type uint8
def test_int64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = -9223372036854775808
self.assertRaises(YPYModelError,
self.crud.create, self.ncc, runner)
# changed to type uint16
def test_uint8(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = 256
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type uint32
def test_uint16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 65536
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type uint64
def test_uint32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 18446744073709551615
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type string
def test_decimal64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.deci64 = 'string'
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to tye decimal64
def test_leafref(self):
runner = self._create_runner()
runner.ytypes.built_in_t.leaf_ref = Decimal64('3.14')
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type empty
def test_string(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = Empty()
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# changed to type YdkEnumTestEnum
def test_boolean(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = YdkEnumTestEnum.NONE
self.crud.create(self.ncc, runner)
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
result = is_equal(runner, runner1)
self.assertEqual(result, True)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.assertRaises(YPYModelError,
self.crud.update, self.ncc, runner)
# max val changed to 7
def test_leaflist_max_elements(self):
runner = self._create_runner()
runner.ytypes.built_in_t.llstring.extend([str(i) for i in range(8)])
self.assertRaises(YPYModelError,
self.crud.create, self.ncc, runner)
# not supported leaf
def test_not_supported_leaf(self):
runner = self._create_runner()
runner.not_supported_1.not_supported_leaf = 'leaf value'
self.assertRaises(YPYModelError,
self.crud.create, self.ncc, runner)
# not supported container
def test_not_supported_container(self):
runner = self._create_runner()
runner.not_supported_1.not_supported_1_2.some_leaf = 'some leaf'
self.assertRaises(YPYModelError,
self.crud.create, self.ncc, runner)
# not supported list
def test_not_supported_list(self):
runner = self._create_runner()
elems = []
for i in range(5):
elems.append(runner.NotSupported2())
runner.not_supported_2.extend(elems)
self.assertRaises(YPYModelError,
self.crud.create, self.ncc, runner)
# 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.extend([str(i) for i in range(20)])
self.assertRaises(YPYModelError,
self.crud.create, self.ncc, runner)
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_read_on_ref_class(self):
r_1 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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):
from ydk.models.ydktest.ydktest_sanity import YdkEnumTestEnum
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.LOCAL
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(), ysanity.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 = ysanity.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 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(), ysanity.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 = ysanity.Runner.OneList()
r_2.ldata.extend([l_1])
r_2 = self.crud.read(self.ncc, r_2)
r_3 = ysanity.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 = ysanity.Runner.Ytypes.BuiltInT()
r_1.llstring = ['1', '2', '3']
self.crud.create(self.ncc, r_1)
r_2 = ysanity.Runner.Ytypes.BuiltInT()
r_2.llstring = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
r_2 = ysanity.Runner.Ytypes.BuiltInT()
# invalid input, user should use READ()
# or the same data on device
r_2.llstring = ['something emaillse']
r_2 = self.crud.read(self.ncc, r_2)
self.assertNotEqual(is_equal(r_1, r_2), True)
def test_read_on_identity_ref(self):
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.identity_ref_value = ysanity.ChildIdentity_Identity()
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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)
# # read issue for identity_ref with namespace, if using netsim
# r_2 = ysanity.Runner.Ytypes.BuiltInT()
# r_2.identity_ref_value = ysanity.ChildIdentity_Identity()
# 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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2, r_3 = ysanity.Runner(), ysanity.Runner()
r_2.one.number, r_3.one.number = READ(), READ()
# only_config=True will change
# <get>XML</get>
# to
# <get-config><source><running/></source>XML</get-config>
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)
Datastore.candidate,
multi_filter)
multi_payload_actual = codec.encode(codec_provider, multi_entity_read)
assert multi_payload_expected == multi_payload_actual
def init_logging():
import logging
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)
if __name__ == "__main__":
init_logging()
provider = NetconfServiceProvider(address='localhost',
username='******',
password='******',
protocol='ssh',
port=1220)
netconf_service = NetconfService()
bgp_run(netconf_service, provider)
# run_multiple_routing_bgp(netconf_service, provider)
exit()
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_read_on_ref_class(self):
r_1 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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):
from ydk.models.ydktest.ydktest_sanity import YdkEnumTestEnum
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.LOCAL
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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 = ysanity.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 = ysanity.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 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(
), ysanity.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 = ysanity.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 = ysanity.Runner.OneList()
l_1, l_2 = ysanity.Runner.OneList.Ldata(
), ysanity.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 = ysanity.Runner.OneList()
r_2.ldata.extend([l_1])
r_2 = self.crud.read(self.ncc, r_2)
r_3 = ysanity.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 = ysanity.Runner.Ytypes.BuiltInT()
r_1.llstring = ['1', '2', '3']
self.crud.create(self.ncc, r_1)
r_2 = ysanity.Runner.Ytypes.BuiltInT()
r_2.llstring = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
r_2 = ysanity.Runner.Ytypes.BuiltInT()
# invalid input, user should use READ()
# or the same data on device
r_2.llstring = ['something emaillse']
r_2 = self.crud.read(self.ncc, r_2)
self.assertNotEqual(is_equal(r_1, r_2), True)
def test_read_on_identity_ref(self):
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.identity_ref_value = ysanity.ChildIdentity_Identity()
self.crud.create(self.ncc, r_1)
r_2 = ysanity.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)
# # read issue for identity_ref with namespace, if using netsim
# r_2 = ysanity.Runner.Ytypes.BuiltInT()
# r_2.identity_ref_value = ysanity.ChildIdentity_Identity()
# 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 = ysanity.Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2, r_3 = ysanity.Runner(), ysanity.Runner()
r_2.one.number, r_3.one.number = READ(), READ()
# only_config=True will change
# <get>XML</get>
# to
# <get-config><source><running/></source>XML</get-config>
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)
# Python script to use YDK Yang tools to edit BGP from ydk.services import CRUDService from ydk.providers import NetconfServiceProvider from ydk.models.openconfig import bgp if __name__ == "__main__": provider = NetconfServiceProvider (address= 'xrv', port = 830, username="******", password="******", protcol="ssh") crud = CRUDService() bgp = bgp.Bgp() bgp.global_.config.as_ = 65000 bgp.global_config.router_id = '10.1.1.1' crud.create(provider, bgp) provider.close()
def get_netconf_provider(self):
provider = NetconfServiceProvider(address=self.mgmt_ip,
port=self.netconf_port,
username=self.username,
password=self.password)
return provider
)
# return formated string
return ping_reply
from ydk.services import ExecutorService
from ydk.models.cisco_ios_xr import Cisco_IOS_XR_ping_act as xr_ping_act
from ydk.providers import NetconfServiceProvider
import logging
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
logger.addHandler(handler)
provider = NetconfServiceProvider(address="198.18.1.11",
port=22,
username='******',
password='******',
protocol='ssh')
executor = ExecutorService()
ping = xr_ping_act.Ping()
ping.input.destination = ping.input.Destination()
ping.input.destination.destination = '192.168.0.2'
ping_output = executor.execute_rpc(provider, ping, ping.output)
print(process_ping_rpc(ping_output))
class SanityNetconf(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityNetconf.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.netconf_service = NetconfService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
from ydk.services import CRUDService
crud = CRUDService()
runner = Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
pass
def test_edit_commit_get(self):
runner = Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
get_filter = Runner()
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate,
runner)
self.assertEqual(None, op)
result = self.netconf_service.get_config(self.ncc, Datastore.candidate,
get_filter)
self.assertEqual(is_equal(runner, result), True)
op = self.netconf_service.commit(self.ncc)
self.assertEqual(None, op)
result = self.netconf_service.get(self.ncc, get_filter)
self.assertEqual(is_equal(runner, result), True)
def test_lock_unlock(self):
op = self.netconf_service.lock(self.ncc, Datastore.running)
self.assertEqual(None, op)
op = self.netconf_service.unlock(self.ncc, Datastore.running)
self.assertEqual(None, op)
def test_lock_unlock_fail(self):
op = self.netconf_service.lock(self.ncc, Datastore.candidate)
self.assertEqual(None, op)
try:
op = self.netconf_service.unlock(self.ncc, Datastore.running)
except Exception as e:
self.assertIsInstance(e, YPYError)
def test_validate(self):
op = self.netconf_service.validate(self.ncc,
source=Datastore.candidate)
self.assertEqual(None, op)
runner = Runner()
runner.one.number = 1
runner.one.name = 'runner:one:name'
op = self.netconf_service.validate(self.ncc, source=runner)
self.assertEqual(None, op)
def test_validate_fail(self):
# should have been handled by YDK local validation
pass
def test_commit_discard(self):
runner = Runner()
runner.two.number = 2
runner.two.name = 'runner:two:name'
get_filter = Runner()
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate,
runner)
self.assertEqual(None, op)
op = self.netconf_service.discard_changes(self.ncc)
self.assertEqual(None, op)
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate,
runner)
self.assertEqual(None, op)
op = self.netconf_service.commit(self.ncc)
self.assertEqual(None, op)
result = self.netconf_service.get(self.ncc, get_filter)
self.assertEqual(is_equal(runner, result), True)
def test_confirmed_commit(self):
runner = Runner()
runner.two.number = 2
runner.two.name = 'runner:two:name'
get_filter = Runner()
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate,
runner)
self.assertEqual(None, op)
op = self.netconf_service.commit(self.ncc,
confirmed=True,
confirm_timeout=120)
self.assertEqual(None, op)
result = self.netconf_service.get(self.ncc, get_filter)
self.assertEqual(is_equal(runner, result), True)
op = self.netconf_service.cancel_commit(self.ncc)
self.assertEqual(None, op)
def test_copy_config(self):
op = self.netconf_service.copy_config(self.ncc, Datastore.candidate,
Datastore.running)
self.assertEqual(None, op)
runner = Runner()
runner.two.number = 2
runner.two.name = 'runner:two:name'
get_filter = Runner()
op = self.netconf_service.edit_config(self.ncc, Datastore.candidate,
runner)
self.assertEqual(None, op)
op = self.netconf_service.copy_config(self.ncc, Datastore.running,
Datastore.candidate)
self.assertEqual(None, op)
result = self.netconf_service.get_config(self.ncc, Datastore.running,
get_filter)
self.assertEqual(is_equal(result, runner), True)
runner.two.name += 'modified'
op = self.netconf_service.copy_config(self.ncc, Datastore.running,
runner)
self.assertEqual(None, op)
result = self.netconf_service.get_config(self.ncc, Datastore.running,
get_filter)
self.assertEqual(is_equal(result, runner), True)
def test_delete_config(self):
pass
# startup and candidate cannot be both enabled in ConfD
# op = self.netconf_service.delete_config(self.ncc, Datastore.startup)
# self.assertEqual(None, op)
def test_delete_config_fail(self):
self.assertRaises(YPYServiceError, self.netconf_service.delete_config,
self.ncc, Datastore.running)
self.assertRaises(YPYServiceError, self.netconf_service.delete_config,
self.ncc, Datastore.candidate)
def test_copy_config_fail(self):
self.assertRaises(YPYServiceError,
self.netconf_service.copy_config,
self.ncc,
target=123,
source=456)
def test_edit_config_fail(self):
self.assertRaises(YPYServiceError, self.netconf_service.edit_config,
self.ncc, Datastore.startup, Datastore.candidate)
def test_get_config_fail(self):
runner = Runner()
self.assertRaises(YPYServiceError, self.netconf_service.get_config,
self.ncc, "invalid-input", runner)
def test_lock_fail(self):
self.assertRaises(YPYServiceError, self.netconf_service.lock, self.ncc,
"invalid-input")
def test_unlock_fail(self):
self.assertRaises(YPYServiceError, self.netconf_service.unlock,
self.ncc, "invalid-input")
from ydk.services import CRUDService
from ydk.providers import NetconfServiceProvider
from ydk.models.cisco_ios_xe import Cisco_IOS_XE_native as xe_model
# CSR1kv1 Credentials
ip = '0.0.0.0'
port_n = 0
user = '******'
paswd = 'password'
proto = 'protocol'
if __name__ == '__main__':
provider = NetconfServiceProvider(address=ip,
port=port_n,
username=user,
password=paswd,
protocol=proto)
# create a CRUD service
# create a new istance of Native Inteface object
# read the interfaces with the help of read function
# print the primary address of the fifth gigabitethernet interface
exit()
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()
ip_domain = xr_ip_domain_cfg.IpDomain() # create object
config_ip_domain(ip_domain) # add object configuration
# create configuration on NETCONF device
crud.create(provider, ip_domain)
provider.close()
exit()
# End of script
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()
# config device with entity a
a = self.getInitEntity()
self.crud.delete(self.ncc, a)
self.crud.create(self.ncc, a)
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
pass
def tearDown(self):
pass
@classmethod
def getInitEntity(self):
""" Set and return entity with following XML:
<a>
<a1>some value</a1>
<a2>value of a2</a2>
<a3>value of a3</a3>
<b>
<b1>some value</b1>
<b2>value of b2</b2>
<b3>value of b3</b3>
<c/>
<f>
<f1>f</f1>
</f>
<d>
<d1>some value d1</d1>
<d2>value of d2</d2>
<d3>value of d3</d3>
<e>
<e1>some value e1</e1>
<e2>value of e2</e2>
</e>
</d>
</b>
<lst>
<number>1</number>
<value>one</value>
</lst>
<lst>
<number>2</number>
<value>two</value>
</lst>
<lst>
<number>3</number>
<value>three</value>
</lst>
</a>
"""
a = ysanity.A()
a.a1, a.a2, a.a3 = "some value", "value of a2", "value of a3"
a.b.b1, a.b.b2, a.b.b3 = "some value", "value of b2", "value of b3"
# config presence container
a.b.f = a.b.F()
a.b.f.f1 = 'f'
a.b.c = a.b.C()
a.b.d.d1 = "some value d1"
a.b.d.d2 = "value of d2"
a.b.d.d3 = "value of d3"
a.b.d.e.e1, a.b.d.e.e2 = "some value e1", "value of e2"
l1, l2, l3 = a.Lst(), a.Lst(), a.Lst()
l1.number, l1.value = 1, "one"
l2.number, l2.value = 2, "two"
l3.number, l3.value = 3, "three"
a.lst.extend([l1, l2, l3])
return a
def test_CASE1(self):
"""Use crud read with top level entity returns all data."""
a = ysanity.A()
a_read = self.crud.read(self.ncc, a)
preconfig_a = self.getInitEntity()
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_CASE2(self):
""" According to https://tools.ietf.org/html/rfc6241#section-6.2.5,
`a.a1` is a content match node. Uses crud read on `a` returns all data.
"""
a = ysanity.A()
a.a1 = "some value"
a_read = self.crud.read(self.ncc, a)
preconfig_a = self.getInitEntity()
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_CASE3(self):
"""Assign a READ object to `a.a1` should only return data on this leaf."""
a = ysanity.A()
a.a1 = READ()
a_read = self.crud.read(self.ncc, a)
preconfig_a = ysanity.A()
preconfig_a.a1 = "some value"
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_CASE4(self):
"""Now `a.b.b1` serves as a content match node."""
a = ysanity.A()
a.b.b1 = "some value"
a_read = self.crud.read(self.ncc, a)
preconfig_a = self.getInitEntity()
del preconfig_a.lst[:]
preconfig_a.a1 = None
preconfig_a.a2 = None
preconfig_a.a3 = None
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_CASE5(self):
"""Now `a.b.d.e` serves as a content match node."""
a = ysanity.A()
e = a.b.d.e
e.e1 = "some value e1"
a_read = self.crud.read(self.ncc, a)
preconfig_a = ysanity.A()
preconfig_a.b.d.e.e1 = "some value e1"
preconfig_a.b.d.e.e2 = "value of e2"
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_CASE6(self):
"""Assign `a.b.c` serves as an empty presence container."""
a = ysanity.A()
a.b.c = a.b.C()
a_read = self.crud.read(self.ncc, a)
preconfig_a = ysanity.A()
preconfig_a.b.c = preconfig_a.b.C()
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_CASE7(self):
"""`item1.number` and `item2.number` serves as content match nodes."""
a = ysanity.A()
item1, item2 = a.Lst(), a.Lst()
item1.number, item2.number = 1, 2
a.lst.extend([item1, item2])
a_read = self.crud.read(self.ncc, a)
preconfig_a = ysanity.A()
item1.value, item2.value = "one", "two"
preconfig_a.lst.extend([item1, item2])
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_CASE8(self):
"""Assign presence class F to `a.b.f`."""
a = ysanity.A()
a.b.f = a.b.F()
a.b.f.f1 = 'f'
a_read = self.crud.read(self.ncc, a)
preconfig_a = a
self.assertEqual(is_equal(a_read, preconfig_a), True)
def test_read_oc_patttern(self):
obj_A = oc_pattern.OcA()
obj_A.a = 'hello'
obj_A.b.b = obj_A.a # 'world' --> YPYServiceProviderError: illegal reference
self.crud.create(self.ncc, obj_A)
obj_A_read = self.crud.read(self.ncc, oc_pattern.OcA(), True)
self.assertEqual(is_equal(obj_A, obj_A_read), True)
