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 SanityMeta(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityMeta.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)
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
pass
def test_normalize_meta_invalid_1(self):
try:
runner = ysanity.Runner()
MetaService.normalize_meta(None, runner)
except YPYServiceError as err:
expected_msg = "'capabilities' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_normalize_meta_invalid_2(self):
try:
MetaService.normalize_meta(self.ncc._get_capabilities(), None)
except YPYServiceError as err:
expected_msg = "'capabilities' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_normalize_meta_invalid_3(self):
try:
runner = ysanity.Runner()
MetaService.normalize_meta(None, None)
except YPYServiceError as err:
expected_msg = "'capabilities' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
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)
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 action(self, crud_action, device):
if crud_action not in ['create']:
raise NotImplemented(crud_action)
from ydk.services import CRUDService
from ydk.providers import NetconfServiceProvider
provider = NetconfServiceProvider(address=device['hostname'],
port=device['port'],
username=device['username'],
password=device['password'],
protocol='ssh')
crud = CRUDService()
crud_instance = getattr(crud, crud_action)
crud_instance(provider, self.binding)
provider.close()
return
def action(self, crud_action, device):
if crud_action not in ['create', 'read']:
raise ValueError(
'Untested or not implemented CRUD action {}'.format(
crud_action))
from ydk.services import CRUDService
from ydk.providers import NetconfServiceProvider
provider = NetconfServiceProvider(address=device['hostname'],
port=device['port'],
username=device['username'],
password=device['password'],
protocol='ssh')
crud = CRUDService()
crud_instance = getattr(crud, crud_action)
result = crud_instance(provider, self.binding)
provider.close()
return result
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 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 = bgp_types.AfiSafiTypeIdentity()
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 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.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 = ysanity.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 = 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.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 = 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.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 = 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.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 = ysanity.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.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()
# new interface
new_loopback = intf.Interfaces.Interface()
# create a new loopback
new_loopback.name = 'Loopback666'
new_loopback.type = iftype.SoftwareloopbackIdentity()
new_loopback.description = 'Created by Einar'
res = crud.create(provider, new_loopback)
provider.close()
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 SanityCrud(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityCrud.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def _create_runner(self):
runner = ysanity.Runner()
runner.ytypes = runner.Ytypes()
runner.ytypes.built_in_t = runner.ytypes.BuiltInT()
return runner
def test_crud_create_invalid_1(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(None, runner)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_crud_create_invalid_2(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_crud_create_invalid_3(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not raised')
def test_crud_delete_invalid_1(self):
try:
runner = self._create_runner()
self.crud.delete(None, runner)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_delete_invalid_2(self):
try:
self.crud.delete(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_delete_invalid_3(self):
try:
self.crud.delete(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_read_invalid_1(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
self.crud.read(None, runner1)
except YPYServiceError as err:
expected_msg = "'provider' and 'read_filter' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_read_invalid_2(self):
try:
self.crud.read(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'read_filter' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_read_invalid_3(self):
try:
self.crud.read(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'read_filter' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_update_invalid_1(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = ysanity.Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.crud.update(None, runner)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_update_invalid_2(self):
try:
self.crud.update(self.ncc, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
def test_crud_update_invalid_3(self):
try:
self.crud.update(None, None)
except YPYServiceError as err:
expected_msg = "'provider' and 'entity' cannot be None"
self.assertEqual(err.message, expected_msg)
else:
raise Exception('YPYServiceError not Raised')
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(
address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def read_from_empty_filter(self):
empty_runner = ysanity.Runner()
return self.crud.read(self.ncc, empty_runner)
def get_nested_object(self):
# return nested object with selected list elements
runner_create = ysanity.Runner()
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner:inbtwlist:['+str(e_1.number)+']:name'
e_1.subc.number = 111
e_1.subc.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:name'
e_2.number = 12
e_2.name = 'runner:inbtwlist:['+str(e_2.number)+']:name'
e_2.subc.number = 121
e_2.subc.name = 'runner:inbtwlist:['+str(e_2.number)+']:name'
e_11 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:subcsubl1['+str(e_11.number)+']:name'
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner:inbtwlist:['+str(e_1.number)+']:subc:subcsubl1['+str(e_12.number)+']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner:inbtwlist:['+str(e_2.number)+']:subc:subcsubl1['+str(e_21.number)+']:name'
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner:inbtwlist:['+str(e_2.number)+']:subc:subcsubl1['+str(e_22.number)+']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
runner_create.inbtw_list.ldata.extend([e_1, e_2])
return runner_create, e_2, e_22
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_on_leaflist_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend([str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
elements_to_delete = runner_create.ytypes.built_in_t.llstring[0:2]
self.crud.delete(self.ncc, elements_to_delete)
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[0:2]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_on_leaflist(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend([str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
self.crud.delete(self.ncc, runner_create.ytypes.built_in_t.llstring[3])
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[3]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1].subc.subc_subl1)
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
del runner_left.inbtw_list.ldata[1].subc.subc_subl1[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list_with_key(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1].subc.subc_subl1[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata[1].subc.subc_subl1.remove(e_22)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_with_key(self):
runner_create, e_2, _ = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata.remove(e_2)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
baz = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
baz.number = 3
baz.name = 'baz'
runner_create.one_list.ldata.extend([foo, bar, baz])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
elements_to_delete = runner_read.one_list.ldata[:1]
self.crud.delete(self.ncc, elements_to_delete)
# read after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete entire list
del runner_left.one_list.ldata[:1]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
runner_create.one_list.ldata.extend([foo, bar])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.one_list.ldata)
# read after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete entire list
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class SanityTest(unittest.TestCase):
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 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.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, 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 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_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)
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
@unittest.skip('DELETE object for leaf-list')
def test_delete_object_on_leaflist(self):
# create runner with a leaf and a leaflist
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring = [str(i) for i in range(5)]
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# user DELETE object to remove leaflist
runner_delete = runner_read
runner_delete.ytypes.built_in_t.llstring = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf one
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
# create runner with a container and a list
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
elem1 = ysanity.Runner.OneList.Ldata()
elem2 = ysanity.Runner.OneList.Ldata()
elem1.number = 1
elem2.name = 'foo'
elem2.number = 1
elem2.name = 'bar'
runner_create.one_list.ldata.extend([elem1, elem2])
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
self.crud.delete(self.ncc, runner_read.one_list.ldata)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class 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 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 SanityTest(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityTest.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
self.ncc.close()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def _create_runner(self):
runner = Runner()
runner.ytypes = runner.Ytypes()
runner.ytypes.built_in_t = runner.ytypes.BuiltInT()
return runner
def test_int8(self):
# Create Runner
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = 126
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = 200000
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_bits(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bits_value['disable-nagle'] = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_int64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = -9223372036854775808
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint8(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = 0
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint16(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 65535
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint32(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 5927
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_uint64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = 18446744073709551615
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_decimal64(self):
runner = self._create_runner()
runner.ytypes.built_in_t.deci64 = Decimal64('3.14')
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_string_1(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = 'name_str'
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_string_2(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = b'name_str'
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
runner.ytypes.built_in_t.name = 'name_str'
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_empty(self):
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = Empty()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
# explicit DELETE not support at the moment
# runner1.ytypes.built_in_t.emptee = DELETE()
# self.crud.update(self.ncc, runner1)
# runner2 = self.crud.read(self.ncc, self._create_runner())
# self.assertEqual(runner2.ytypes.built_in_t.emptee, None)
def test_boolean(self):
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = True
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = False
self.crud.update(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_embedded_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.embeded_enum = Runner.Ytypes.BuiltInT.EmbededEnumEnum.zero
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = YdkEnumTestEnum.none
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion = YdkEnumTestEnum.none
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = YdkEnumIntTestEnum.any
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_int(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = 2
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_recursive(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion_recursive = 18
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_list(self):
runner = self._create_runner()
runner.ytypes.built_in_t.llunion.append(1)
runner.ytypes.built_in_t.llunion.append(3)
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
@unittest.skip('ConfD internal error.')
def test_bits_leaflist(self):
# User needs to append Bits instance manually to bits leaflist.
runner = self._create_runner()
bits_0 = runner.ytypes.built_in_t.BitsLlist_Bits()
bits_1 = runner.ytypes.built_in_t.BitsLlist_Bits()
bits_0['disable-nagle'] = True
bits_1['auto-sense-speed'] = True
runner.ytypes.built_in_t.bits_llist.extend([bits_0, bits_1])
self.crud.create(self.ncc, runner)
# Read into Runner1
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_enum_leaflist(self):
runner = self._create_runner()
runner.ytypes.built_in_t.enum_llist.append(YdkEnumTestEnum.local)
runner.ytypes.built_in_t.enum_llist.append(YdkEnumTestEnum.remote)
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_identity_leaflist(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_llist.append(ChildIdentityIdentity())
runner.ytypes.built_in_t.identity_llist.append(
ChildChildIdentityIdentity())
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
#DEEPCOPY
runner_copy = copy.deepcopy(runner)
# result = is_equal(runner, runner_copy)
# self.assertEqual(result, True)
self.crud.delete(self.ncc, Runner())
self.crud.create(self.ncc, runner_copy)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_union_complex_list(self):
runner = self._create_runner()
runner.ytypes.built_in_t.younion_list.append('123:45')
runner.ytypes.built_in_t.younion_list.append(23)
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
union_list = runner.ytypes.built_in_t.younion_list
self.assertTrue(23 in union_list and '123:45' in union_list)
def test_identityref(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
ChildIdentityIdentity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_status_enum(self):
runner = self._create_runner()
runner.ytypes.built_in_t.status = runner.ytypes.built_in_t.StatusEnum.not_connected
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
def test_leaflist_unique(self):
runner = self._create_runner()
with self.assertRaises(YPYModelError):
runner.ytypes.built_in_t.llstring.extend([None for i in range(3)])
def test_list_max_elements(self):
runner = self._create_runner()
elems = []
n = 10
for i in range(n):
l = Runner.OneList.Ldata()
l.number = i
l.name = str(i)
elems.append(l)
runner.one_list.ldata.extend(elems)
self.assertRaises(YPYModelError, self.crud.create, self.ncc, runner)
def test_submodule(self):
subtest = SubTest()
subtest.one_aug.name = 'test'
subtest.one_aug.number = 3
res = self.crud.create(self.ncc, subtest)
subtest1 = self.crud.read(self.ncc, SubTest())
# Compare runners
result = is_equal(subtest, subtest1)
self.assertEqual(result, True)
def test_identity_from_other_module(self):
runner = self._create_runner()
runner.ytypes.built_in_t.identity_ref_value = \
YdktestTypeIdentity()
self.crud.create(self.ncc, runner)
# Read into Runner2
runner1 = Runner()
runner1 = self.crud.read(self.ncc, runner1)
# Compare runners
result = is_equal(runner, runner1)
self.assertEqual(result, True)
class 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 SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ncc = NetconfServiceProvider(
address='127.0.0.1', username='******',
password='******', protocol='ssh', port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
@unittest.skip('DELETE object for leaf-list')
def test_delete_object_on_leaflist(self):
# create runner with a leaf and a leaflist
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring = [str(i) for i in range(5)]
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# user DELETE object to remove leaflist
runner_delete = runner_read
runner_delete.ytypes.built_in_t.llstring = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf one
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
# create runner with a container and a list
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
elem1 = ysanity.Runner.OneList.Ldata()
elem2 = ysanity.Runner.OneList.Ldata()
elem1.number = 1
elem2.name = 'foo'
elem2.number = 1
elem2.name = 'bar'
runner_create.one_list.ldata.extend([elem1, elem2])
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
self.crud.delete(self.ncc, runner_read.one_list.ldata)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class SanityYang(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityYang.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
self.ncc.close()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def test_read_on_ref_class(self):
r_1 = Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2.one = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
def test_read_on_leaf(self):
r_1 = Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2.one.number = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_2.one.number, r_1.one.number)
# this will also read r_2.one.name, not able to read only one of them
r_2 = Runner()
r_2.one.number = 1
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_2.one.number, r_1.one.number)
# no such value, will return empty data
r_2 = Runner()
r_2.one.number = 2
r_2 = self.crud.read(self.ncc, r_2)
self.assertNotEqual(r_2.one.number, r_1.one.number)
def test_read_on_ref_enum_class(self):
r_1 = Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.local
self.crud.create(self.ncc, r_1)
r_2 = Runner.Ytypes.BuiltInT()
r_2.enum_value = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
r_2 = Runner.Ytypes.BuiltInT()
r_2.enum_value = YdkEnumTestEnum.local
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# no such value, nothing returned
r_2 = Runner.Ytypes.BuiltInT()
r_2.enum_value = YdkEnumTestEnum.remote
r_2 = self.crud.read(self.ncc, r_2)
self.assertNotEqual(is_equal(r_1, r_2), True)
def test_read_on_ref_list(self):
r_1 = Runner.OneList()
l_1, l_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
l_1.number, l_2.number = 1, 2
r_1.ldata.extend([l_1, l_2])
self.crud.create(self.ncc, r_1)
r_2 = Runner.OneList()
r_2.ldata = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
def test_read_on_list_with_key(self):
r_1 = Runner.OneList()
l_1, l_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
l_1.number, l_2.number = 1, 2
r_1.ldata.extend([l_1, l_2])
self.crud.create(self.ncc, r_1)
r_2 = Runner.OneList()
r_2.ldata.extend([l_1])
r_2 = self.crud.read(self.ncc, r_2)
r_3 = Runner.OneList()
r_3.ldata.extend([l_1])
self.assertEqual(is_equal(r_2, r_3), True)
def test_read_on_leaflist(self):
r_1 = Runner.Ytypes.BuiltInT()
r_1.llstring.extend(['1', '2', '3'])
self.crud.create(self.ncc, r_1)
r_2 = Runner.Ytypes.BuiltInT()
r_2.llstring.extend(['1', '2', '3'])
runner_read = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, runner_read), True)
r_2 = Runner.Ytypes.BuiltInT()
# invalid input, user should use READ()
# or the same data on device
r_2.llstring.extend(['something else'])
runner_read = self.crud.read(self.ncc, r_2)
self.assertNotEqual(is_equal(r_1, runner_read), True)
def test_read_on_identity_ref(self):
r_1 = Runner.Ytypes.BuiltInT()
r_1.identity_ref_value = ChildIdentityIdentity()
self.crud.create(self.ncc, r_1)
r_2 = Runner.Ytypes.BuiltInT()
r_2.identity_ref_value = READ()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
r_2 = Runner.Ytypes.BuiltInT()
r_2.identity_ref_value = ChildIdentityIdentity()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
def test_read_only_config(self):
r_1 = Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2, r_3 = Runner(), Runner()
r_2.one.number, r_3.one.number = READ(), READ()
r_2 = self.crud.read(self.ncc, r_2, only_config=True)
r_3 = self.crud.read(self.ncc, r_3)
# ysanity only have config data, ok to compare
self.assertEqual(is_equal(r_2, r_3), True)
def test_decoder(self):
# send payload to device
runner = Runner()
element = Runner.OneList.Ldata()
element.number = 5
element.name = 'five'
runner.one_list.ldata.append(element)
self.crud.create(self.ncc, runner)
self.crud.read(self.ncc, Runner.OneList.Ldata())
def test_replace_on_leaf(self):
one = Runner.One()
one.number, one.name = 1, 'runner-one-name'
self.crud.create(self.ncc, one)
filter = Runner.One()
filter.number = READ()
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.number, one.number)
# Replace leaf value and verify
one = Runner.One()
one.name = REPLACE('runner_one_name')
one.number = MERGE(2)
self.crud.update(self.ncc, one)
filter = Runner.One()
filter.name = READ()
filter.number = READ()
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.name, 'runner_one_name')
self.assertEqual(r.number, 2)
one = Runner.One()
one.number = REMOVE()
self.crud.update(self.ncc, one)
one.number = CREATE(3)
self.crud.update(self.ncc, one)
r = self.crud.read(self.ncc, Runner.One())
self.assertEqual(r.name, 'runner_one_name')
self.assertEqual(r.number, 3)
def test_replace_on_enum(self):
# Create and verify
btc = Runner.Ytypes.BuiltInT()
btc.enum_value = YdkEnumTestEnum.local
self.crud.create(self.ncc, btc)
filter = Runner.Ytypes.BuiltInT()
filter.enum_value = READ()
r = self.crud.read(self.ncc, filter)
self.assertTrue(is_equal(r, btc))
# Replace and Verify
btr = Runner.Ytypes.BuiltInT()
btr.enum_value = REPLACE(YdkEnumTestEnum.remote)
self.crud.update(self.ncc, btr)
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.enum_value, YdkEnumTestEnum.remote)
def test_create_identity_ref(self):
# Create and Verify
btc = Runner.Ytypes.BuiltInT()
btc.identity_ref_value = CREATE(ChildIdentityIdentity())
self.crud.update(self.ncc, btc)
filter = Runner.Ytypes.BuiltInT()
filter.identity_ref_value = READ()
r = self.crud.read(self.ncc, filter)
self.assertTrue(is_equal(r.identity_ref_value,
ChildIdentityIdentity()))
def test_replace_on_list(self):
one_list = Runner.OneList()
ld1, ld2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
ld1.number, ld2.number = 1, 2
one_list.ldata.extend([ld1, ld2])
self.crud.create(self.ncc, one_list)
filter = Runner.OneList.Ldata()
filter.number = 2
r = self.crud.read(self.ncc, filter)
self.assertTrue(is_equal(r, ld2))
# Merge and Verify
one_merge = Runner.OneList()
ld3 = Runner.OneList.Ldata()
ld3.number = 3
one_merge.ldata.append(ld3)
one_merge.yfilter = MERGE()
self.crud.update(self.ncc, one_merge)
r = self.crud.read(self.ncc, Runner.OneList())
self.assertEqual(len(r.ldata), 3)
# Replace and Verify
replace = Runner.OneList()
replace.ldata.append(ld3)
replace.yfilter = REPLACE()
self.crud.update(self.ncc, replace)
r = self.crud.read(self.ncc, Runner.OneList())
self.assertEqual(len(r.ldata), 1)
def test_replace_on_container(self):
one = Runner.One()
one.number, one.name = 1, 'runner-one-name'
self.crud.create(self.ncc, one)
filter = Runner.One()
r = self.crud.read(self.ncc, filter)
self.assertEqual(one.number, r.number)
# Replace container value and verify
one.yfilter = REPLACE()
one.name = 'runner_one_name'
one.number = 2
self.crud.update(self.ncc, one)
r = self.crud.read(self.ncc, filter)
self.assertEqual(r.name, 'runner_one_name')
self.assertEqual(r.number, 2)
one.yfilter = REMOVE()
self.crud.update(self.ncc, one)
r = self.crud.read(self.ncc, Runner.One())
self.assertIsNone(r.name)
self.assertIsNone(r.number)
class SanityNetconf(unittest.TestCase):
@classmethod
def setUpClass(self):
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)
print '\nIn method', self._testMethodName + ':'
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, YPYDataValidationError)
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 YDKTarget:
def __init__(self,
host=None,
username=None,
password=None,
port=NETCONF_PORT):
self._address = host
self._port = port
self._username = username
self._password = password
self._provider = None
self._crudService = CRUDService()
# Just in case an error occurs somewhere in the YDK API. It will mess with
# Ansible, but at least there's a chance of seeing what happened
@staticmethod
def _setupLogging():
logger = logging.getLogger('ydk')
# logger.setLevel(logging.DEBUG)
logger.setLevel(logging.ERROR)
handler = logging.StreamHandler()
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
def checkParams(self):
if self._address is None:
return YDKTargetParamError(True, 'missing host parameter')
if self._username is None:
return YDKTargetParamError(True, 'missing username parameter')
if self._password is None:
return YDKTargetParamError(True, 'missing password parameter')
return YDKTargetParamError(False, 'ok')
def info(self):
return [self._address, self._port, self._username, self._password]
def connect(self):
self._setupLogging()
self._provider = NetconfServiceProvider(address=self._address,
port=self._port,
username=self._username,
password=self._password)
def close(self):
self._provider.close()
def create(self, config):
return self._crudService.create(self._provider, config)
def read(self, filterSpec):
return self._crudService.read(self._provider, filterSpec)
def update(self, config):
return self._crudService.update(self._provider, config)
def delete(self, config):
return self._crudService.delete(self._provider, config)
def getCapabilities(self):
return self._provider._get_capabilities()
def validateModelCapability(self, modelName):
pattern = re.compile(modelName + '\?')
capabilities = self._provider._get_capabilities()
for capability in capabilities:
if pattern.match(capability):
return True
return False
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 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')
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):
@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
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 assertRaisesWithPattern(self, pattern, func, *args, **kwargs):
try:
func(*args, **kwargs)
self.assertFail()
except Exception as inst:
res = re.match(pattern, inst.message)
self.assertEqual(res is not None, True)
def test_invalid_class_assignment_int(self):
runner = ysanity.Runner()
runner.one = 1
self.assertRaisesWithPattern(
"Attempt to assign non YDK entity object of type "
"int to [a-zA-Z\.]*One", self.crud.create, self.ncc, runner)
def test_invalid_class_assignment_str(self):
runner = ysanity.Runner()
runner.one = "haha"
self.assertRaisesWithPattern(
"Attempt to assign non YDK entity object of type "
"str to [a-zA-Z\.]*One", self.crud.create, self.ncc, runner)
def test_invalid_class_assignment_identity(self):
runner = ysanity.Runner()
runner.one = ytypes.AnotherOneIdentity()
self.assertRaisesWithPattern(
"Attempt to assign non YDK entity object of type "
"AnotherOneIdentity to [a-zA-Z\.]*One", self.crud.create, self.ncc,
runner)
def test_invalid_class_assignment_enum(self):
runner = ysanity.Runner()
runner.one = ysanity.YdkEnumTestEnum.none
self.assertRaisesWithPattern(
"Attempt to assign non YDK entity object of type "
"YdkEnumTestEnum to [a-zA-Z\.]*One", self.crud.create, self.ncc,
runner)
def test_invalid_class_assignment_ylist(self):
runner = ysanity.Runner()
elem = ysanity.Runner.OneList.Ldata()
elem.number, elem.name = 1, '1'
runner.one_list.ldata.append(elem)
runner.one = runner.one_list.ldata
self.assertRaisesWithPattern(
"Attempt to assign non YDK entity object of type "
"YList to [a-zA-Z\.]*One", self.crud.create, self.ncc, runner)
def test_invalid_class_assignment_yleaflist(self):
runner = ysanity.Runner()
runner.ytypes.built_in_t.llstring.extend([str(i) for i in range(5)])
runner.one = runner.ytypes.built_in_t.llstring
self.assertRaisesWithPattern(
"Attempt to assign non YDK entity object of type "
"YLeafList to [a-zA-Z\.]*One", self.crud.create, self.ncc, runner)
def test_invalid_list_assignment_int(self):
runner = ysanity.Runner()
runner.one_list.ldata = 1
self.assertRaisesWithPattern(
"Attempt to assign object of type int to YList ldata. "
"Please use list append or extend method.", self.crud.create,
self.ncc, runner)
def test_invalid_list_assignment_entity(self):
runner = ysanity.Runner()
runner.one_list.ldata = runner.one
self.assertRaisesWithPattern(
"Attempt to assign object of type One to YList ldata. "
"Please use list append or extend method.", self.crud.create,
self.ncc, runner)
def test_invalid_list_assignment_llist(self):
runner = ysanity.Runner()
runner.ytypes.built_in_t.llstring.extend([str(i) for i in range(5)])
runner.one_list.ldata = runner.ytypes.built_in_t.llstring
self.assertRaisesWithPattern(
"Attempt to assign object of type YLeafList to YList ldata. "
"Please use list append or extend method.", self.crud.create,
self.ncc, runner)
def test_invalid_llist_assignment_int(self):
# Wrongly assign empty YList or YLeaflist will not change payload.
runner = ysanity.Runner()
runner.ytypes.built_in_t.llstring = 1
self.assertRaisesWithPattern(
"Attempt to assign object of type int to YLeafList llstring. "
"Please use list append or extend method.", self.crud.create,
self.ncc, runner)
def test_invalid_llist_assignment_list(self):
runner = ysanity.Runner()
elem = ysanity.Runner.OneList.Ldata()
elem.number, elem.name = 1, '1'
runner.one_list.ldata.append(elem)
runner.ytypes.built_in_t.llstring = runner.one_list.ldata
self.assertRaisesWithPattern(
"Attempt to assign object of type YList to YLeafList llstring. "
"Please use list append or extend method.", self.crud.create,
self.ncc, runner)
class SanityYang(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityYang.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
def read_from_empty_filter(self):
empty_runner = ysanity.Runner()
return self.crud.read(self.ncc, empty_runner)
def get_nested_object(self):
# return nested object with selected list elements
runner_create = ysanity.Runner()
e_1 = ysanity.Runner.InbtwList.Ldata()
e_2 = ysanity.Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner:inbtwlist:[11]:name'
e_1.subc.number = 111
e_1.subc.name = 'runner:inbtwlist:[11]:subc:name'
e_2.number = 12
e_2.name = 'runner:inbtwlist:[12]:name'
e_2.subc.number = 121
e_2.subc.name = 'runner:inbtwlist:[12]:name'
e_11 = e_1.subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner:inbtwlist:[11]:subc:subcsubl1[111]:name'
e_12 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner:inbtwlist:[11]:subc:subcsubl1[112]:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner:inbtwlist:[12]:subc:subcsubl1[121]:name'
e_22 = ysanity.Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner:inbtwlist:[12]:subc:subcsubl1[122]:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
runner_create.inbtw_list.ldata.extend([e_1, e_2])
return runner_create, e_2, e_22
def test_delete_object_on_leaf(self):
# create runner with two leaves, one and two
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# use DELETE object to remove leaf one
runner_delete = runner_read
runner_delete.one.name = DELETE()
self.crud.update(self.ncc, runner_delete)
# manually create remaining runner with leaf two
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.one.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_on_leaflist_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend(
[str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
elements_to_delete = runner_create.ytypes.built_in_t.llstring[0:2]
self.crud.delete(self.ncc, elements_to_delete)
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[0:2]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_on_leaflist(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.ytypes.built_in_t.llstring.extend(
[str(i) for i in range(5)])
self.crud.create(self.ncc, runner_create)
self.crud.delete(self.ncc, runner_create.ytypes.built_in_t.llstring[3])
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.ytypes.built_in_t.llstring[3]
self.assertEqual(is_equal(runner_read, runner_create), True)
def test_delete_on_list_with_identitykey(self):
runner = ysanity.Runner()
a1 = ysanity.Runner.OneList.IdentityList()
a1.config.id = ysanity.ChildIdentityIdentity()
a1.id_ref = a1.config.id
runner.one_list.identity_list.extend([a1])
self.crud.create(self.ncc, runner)
empty_runner = ysanity.Runner()
runner_read = self.crud.read(self.ncc, empty_runner)
self.crud.delete(self.ncc, runner_read.one_list.identity_list)
runner_read = self.crud.read(self.ncc, empty_runner)
self.assertEqual(len(runner_read.one_list.identity_list), 0)
def test_delete_operation_on_container(self):
# create runner with a container
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
runner_create.two.name = 'two'
self.crud.create(self.ncc, runner_create)
runner_read_filter = ysanity.Runner()
runner_read = self.crud.read(self.ncc, runner_read_filter)
# delete contianer two
self.crud.delete(self.ncc, runner_read.two)
runner_read = self.crud.read(self.ncc, runner_read_filter)
runner_left = runner_create
runner_left.two.name = None
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc,
runner_read.inbtw_list.ldata[1].subc.subc_subl1)
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
del runner_left.inbtw_list.ldata[1].subc.subc_subl1[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_nested_list_with_key(self):
runner_create, _, e_22 = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc,
runner_create.inbtw_list.ldata[1].subc.subc_subl1[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata[1].subc.subc_subl1.remove(e_22)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_with_key(self):
runner_create, e_2, _ = self.get_nested_object()
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.inbtw_list.ldata[1])
# get object after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete element e_2 in runner_create object
runner_left.inbtw_list.ldata.remove(e_2)
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list_slice(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
baz = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
baz.number = 3
baz.name = 'baz'
runner_create.one_list.ldata.extend([foo, bar, baz])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
elements_to_delete = runner_read.one_list.ldata[:1]
self.crud.delete(self.ncc, elements_to_delete)
# read after a crud delete operation
runner_read = self.read_from_empty_filter()
runner_left = runner_create
# manually delete entire list
del runner_left.one_list.ldata[:1]
self.assertEqual(is_equal(runner_read, runner_left), True)
def test_delete_operation_on_list(self):
runner_create = ysanity.Runner()
runner_create.one.name = 'one'
foo = ysanity.Runner.OneList.Ldata()
bar = ysanity.Runner.OneList.Ldata()
foo.number = 1
foo.name = 'foo'
bar.number = 2
bar.name = 'bar'
runner_create.one_list.ldata.extend([foo, bar])
self.crud.create(self.ncc, runner_create)
runner_read = self.read_from_empty_filter()
self.crud.delete(self.ncc, runner_read.one_list.ldata)
runner_read = self.read_from_empty_filter()
runner_left = runner_create
del runner_left.one_list.ldata[:]
self.assertEqual(is_equal(runner_read, runner_left), True)
class 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)
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)
# Create Connection parameters
connection = NetconfServiceProvider(address=device.mgmtip,
port=device.netconfport,
username=device.username,
password=device.password)
# Read Interface YANG Model
nativereaddata = crud.read(connection, readintobject)
provider = CodecServiceProvider(type="xml")
codec = CodecService()
xmls = codec.encode(provider, nativereaddata)
# Convert Read Interface Data to Dictionary and parse for L3 Interface List
returneddict = xmltodict.parse(xmls)
xmllist = list(returneddict['interface'].keys())
xmlmoddedlist = xmllist[1:]
# Interate over Interfaces to create a list of L3 interfaces
rawl3intlist = [
inttype.capitalize() + intlist['name']
if type(intlist) is OrderedDict else inttype.capitalize() +
returneddict['interface'][inttype]['name']
if intlist == 'name' else None for inttype in xmlmoddedlist
for intlist in returneddict['interface'][inttype]
]
l3intlist = list(filter(lambda x: x != None, rawl3intlist))
loopbackdata = addloopback(loopbackobject, device)
xaddloopback = crud.create(connection, loopbackdata)
# Apply Configuration over Connection
configdata = multicast(multicastobject, device, l3intlist)
xmulticast = crud.create(connection, configdata)
connection.close()
#Set a new value
if initial_bgp.global_.config.as_:
bgp_config.global_.config.as_ = initial_bgp.global_.config.as_ - 1
#Delete the configuration entity so that we can create a new one
crud_service.delete(xr_provider, bgp_config)
else:
bgp_config.global_.config.as_ = 65000
#Create the configuration
crud_service.create(xr_provider, bgp_config)
#Read and print the new value
new_bgp = crud_service.read(xr_provider, bgp_config)
print("The new BGP ASN value is - " + str(new_bgp.global_.config.as_))
if initial_bgp.global_.config.as_:
#Reset to initial value
crud_service.delete(xr_provider, bgp_config)
crud_service.create(xr_provider, initial_bgp)
#Read and print the value now that we have reset it
initial_bgp = crud_service.read(xr_provider, bgp_config)
print("The BGP ASN value is now - " + str(initial_bgp.global_.config.as_))
#Try and set to invalid value
bgp_config.global_.config.as_ = -1
try:
crud_service.create(xr_provider, bgp_config)
except YPYModelError as e:
print("Setting the ASN to -1 didn't work, as expected - " + str(e))
xr_provider.close()
class YDKNetconfProvider(object):
"""Contains methods for managing and using YDK provider connections to network devices"""
__existing_connections = {}
def __init__(self, proto='ssh'):
self._session = None
self._node = None
self._proto = proto
def _node_hash(self, node, port):
"""Get IP address and port hash from node dictionary.
:param node: Node in topology.
:param port:
:type node: dict
:return: IP address and port for the specified node.
:rtype: int
"""
return hash(frozenset([node['mgmt_ip'], port]))
def open_netconf_session(self, node):
"""Connect to node using YDK's Netconf service provider.
"""
self._node = node
netconf_port = Topology.get_netconf_port_from_node(node)
print "netconf port Is !!!" + str(netconf_port)
node_hash = self._node_hash(node, netconf_port)
if node_hash in YDKNetconfProvider.__existing_connections:
self._session = YDKNetconfProvider.__existing_connections[
node_hash]
logger.debug('reusing netconf session: {0}'.format(self._session))
else:
start = time()
self._session = NetconfServiceProvider(address=node['mgmt_ip'],
port=netconf_port,
username=node['username'],
password=node['password'],
protocol=self._proto)
YDKNetconfProvider.__existing_connections[
node_hash] = self._session
logger.trace('connect took {} seconds'.format(time() - start))
logger.debug('new connection: {0}'.format(self._session))
logger.debug('Connections: {0}'.format(
str(YDKNetconfProvider.__existing_connections)))
return self._session
def close_netconf_session(self, node):
"""Close netconf connection to the node.
:param node: The node to disconnect from.
:type node: dict
"""
node_hash = self._node_hash(node, netconf)
if node_hash in YDKNetconfProvider.__existing_connections:
logger.debug('Disconnecting peer: {}, {}'.format(
node['name'], node['port']))
ssh = YDKNetconfProvider.__existing_connections.pop(node_hash)
self._session.close()
def _reconnect(self):
"""Close the SSH connection and open it again."""
node = self._node
self.close_netconf_session(node)
self.start_netconf_session(node)
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 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_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number8 = 8.5
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.number8: (INVALID_TYPE, Invalid type: 'float'. Expected type: 'int')"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_int16_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number16 = {}
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.number16: (INVALID_TYPE, Invalid type: 'dict'. Expected type: 'int')"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_int32_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number32 = []
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.number32: (INVALID_TYPE, Invalid type: 'list'. Expected type: 'int')"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_int64_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.number64 = 9223372036854775808
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.number64: (INVALID_VALUE, Value is invalid: 9223372036854775808 not in range (-9223372036854775808, 9223372036854775807))"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
# runner = self._create_runner()
# runner.ytypes.built_in_t.number64 = 9223372036854775808
# self.crud.create(self.ncc, runner)
def test_uint8_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = -1
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.u_number8: (INVALID_VALUE, Value is invalid: -1 not in range (0, 255))"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_uint16_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.u_number16 = 'not an uint'
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.u_number16: (INVALID_TYPE, Invalid type: 'str'. Expected type: 'int')"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_uint32_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.u_number32 = 4294967296
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.u_number32: (INVALID_VALUE, Value is invalid: 4294967296 not in range (0, 4294967295))"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_uint64_invalid_1(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = -1
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.u_number64: (INVALID_VALUE, Value is invalid: -1 not in range (0, 18446744073709551615))"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_uint64_invalid_2(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.u_number64 = 18446744073709551616
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.u_number64: (INVALID_VALUE, Value is invalid: 18446744073709551616 not in range (0, 18446744073709551615))"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_string_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.name = ['name_str']
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.name: (INVALID_TYPE, Invalid type: 'list'. Expected type: 'str')"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_empty_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = '0'
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.emptee: (INVALID_TYPE, Invalid type: 'str'. Expected type: 'Empty')"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_boolean_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.bool_value = ''
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.bool_value: (INVALID_TYPE, Invalid type: 'str'. Expected type: 'bool')"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_enum_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = 'not an enum'
self.crud.create(self.ncc, runner)
except YPYModelError as err:
expected_msg = "Runner.Ytypes.BuiltInT.enum_value: (INVALID_TYPE, Invalid type: 'str'. Expected type: Enum)"
self.assertEqual(err.message.strip(), expected_msg)
else:
raise Exception('YPYModelError not raised')
def test_yleaflist_assignment(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.llstring = [
'invalid', 'leaf-list', 'assignment'
]
self.crud.create(self.ncc, runner)
except YPYServiceError as err:
expected_msg = "Attempt to assign object of type list to YLeafList llstring. Please use list append or extend method."
self.assertEqual(err.message.strip(), expected_msg)
def test_ylist_assignment(self):
try:
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 = elems
self.crud.create(self.ncc, runner)
except YPYServiceError as err:
expected_msg = "Attempt to assign object of type list to YList ldata. Please use list append or extend method."
self.assertEqual(err.message.strip(), expected_msg)
class SanityTest(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityTest.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
runner = ysanity.Runner()
self.crud.delete(self.ncc, runner)
self.ncc.close()
def setUp(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_invalid(self):
try:
runner = self._create_runner()
runner.yvalidate = False
runner.ytypes.built_in_t.number8 = 8.5
self.crud.create(self.ncc, runner)
except YPYServiceProviderError as err:
expected_msg = '<error-message xml:lang="en">"8.5" is not a valid value.</error-message>'
self.assertTrue(expected_msg in err.message)
else:
raise Exception(
'YPYServiceProviderError was not raised as expected')
def test_uint_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.u_number8 = -1
runner.ytypes.built_in_t.yvalidate = False
self.crud.create(self.ncc, runner)
except YPYServiceProviderError as err:
expected_msg = '<error-message xml:lang="en">"-1" is not a valid value.</error-message>'
self.assertTrue(expected_msg in err.message)
else:
raise Exception(
'YPYServiceProviderError was not raised as expected')
def test_string_invalid(self):
runner = self._create_runner()
runner.ytypes.built_in_t.name = ['name_str']
runner.ytypes.yvalidate = False
self.crud.create(self.ncc, runner)
def test_empty_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.emptee = 1
runner.ytypes.built_in_t.yvalidate = False
self.crud.create(self.ncc, runner)
except YPYServiceProviderError as err:
expected_msg = '<error-message xml:lang="en">got unexpected data "1" for a container</error-message>'
self.assertTrue(expected_msg in err.message.strip())
else:
raise Exception(
'YPYServiceProviderError was not raised as expected')
def test_enum_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.enum_value = 'not an enum'
runner.ytypes.built_in_t.yvalidate = False
self.crud.create(self.ncc, runner)
except YPYServiceProviderError as err:
expected_msg = '<error-message xml:lang="en">"" is an invalid value.</error-message><error-info><bad-element>enum-value</bad-element>'
self.assertTrue(expected_msg in err.message)
else:
raise Exception(
'YPYServiceProviderError was not raised as expected')
def test_enum_range_invalid(self):
try:
runner = self._create_runner()
runner.ytypes.built_in_t.enum_int_value = 20000
runner.ytypes.built_in_t.yvalidate = False
self.crud.create(self.ncc, runner)
except YPYServiceProviderError as err:
expected_msg = '<error-message xml:lang="en">"20000" is not a valid value.</error-message>'
self.assertTrue(expected_msg in err.message)
except YPYError as err:
raise Exception('Unexpected exception occured: %s' %
err.message.strip())
else:
raise Exception(
'YPYServiceProviderError was not raised as expected')
def test_str_pattern_invalid(self):
try:
one = ysanity.Runner.LeafRef.One()
one.name_of_one = '1.2.3'
one.yvalidate = False
self.crud.create(self.ncc, one)
except YPYServiceProviderError as err:
expected_msg = '<error-message xml:lang="en">"1.2.3" is an invalid value.</error-message>'
self.assertTrue(expected_msg in err.message)
except YPYError as err:
raise Exception('Unexpected exception occured: %s' %
err.message.strip())
else:
raise Exception(
'YPYServiceProviderError was not raised as expected')
class SanityYang(unittest.TestCase):
PROVIDER_TYPE = "non-native"
@classmethod
def setUpClass(self):
if SanityYang.PROVIDER_TYPE == "native":
self.ncc = NativeNetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
else:
self.ncc = NetconfServiceProvider(address='127.0.0.1',
username='******',
password='******',
protocol='ssh',
port=12022)
self.crud = CRUDService()
@classmethod
def tearDownClass(self):
self.ncc.close()
def setUp(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def tearDown(self):
runner = Runner()
self.crud.delete(self.ncc, runner)
def test_one_level_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
r_1.one.number, r_1.one.name = 1, 'runner:one:name'
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.one.number, r_1.one.name = 10, 'runner/one/name'
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_two_level_pos(self):
# READ
r_1 = Runner()
r_1.two.number, r_1.two.name, r_1.two.sub1.number = 2, 'runner:two:name', 21
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.two.number, r_1.two.name, r_1.two.sub1.number = 20, 'runner/two/name', 210
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_three_level_pos(self):
# READ
r_1 = Runner()
r_1.three.number, r_1.three.name, \
r_1.three.sub1.number, r_1.three.sub1.sub2.number = 3, 'runner:three:name', 31, 311
self.crud.create(self.ncc, r_1)
r_2 = Runner()
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.three.number, r_1.three.name, \
r_1.three.sub1.number, r_1.three.sub1.sub2.number = 30, 'runner/three/name', 310, 3110
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_onelist_neg_dupkey(self):
# netsim/enxr not complaining
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_2.name = 'foo'
e_2.number = 1
e_2.name = 'bar'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
def test_onelist_neg_update_key_nonexist(self):
# will create a nonexist elem
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
r_1.one_list.ldata.extend([e_1])
self.crud.create(self.ncc, r_1)
r_1.one_list.ldata[0].number = 2
r_1.one_list.ldata[0].name = '2'
r_1.one_list.ldata[0].yfilter = DELETE()
# assuming update on nonexist key will raise Exception
with self.assertRaises(Exception):
self.crud.update(self.ncc, r_1.one_list.ldata[0])
def test_onelsit_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
e_2.number = 2
e_2.name = 'runner:onelist:ldata[' + str(e_2.number) + ']:name'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
e_1.number = 1
e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
e_2.number = 2
e_2.name = 'runner:onelist:ldata[' + str(e_2.number) + ']:name'
r_1.one_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_twolist_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.TwoList.Ldata(), Runner.TwoList.Ldata()
e_11, e_12 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:name'
e_11.number = 211
e_11.name = 'runner:twolist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
e_12.number = 212
e_12.name = 'runner:twolist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:name'
e_21.number = 221
e_21.name = 'runner:twolist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
e_22.number = 222
e_22.name = 'runner:twolist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1, e_2 = Runner.TwoList.Ldata(), Runner.TwoList.Ldata()
e_11, e_12 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner/twolist/ldata[' + str(e_1.number) + ']/name'
e_11.number = 211
e_11.name = 'runner/twolist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/name'
e_12.number = 212
e_12.name = 'runner/twolist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner/twolist/ldata[' + str(e_2.number) + ']/name'
e_21.number = 221
e_21.name = 'runner/twolist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/name'
e_22.number = 222
e_22.name = 'runner/twolist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_threelist_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1 = Runner.ThreeList.Ldata()
e_1.number = 31
e_1.name = 'runner:threelist:ldata[' + str(e_1.number) + ']:name'
e_2 = Runner.ThreeList.Ldata()
e_2.number = 32
e_2.name = 'runner:threelist:ldata[' + str(e_2.number) + ']:name'
e_11 = Runner.ThreeList.Ldata.Subl1()
e_12 = Runner.ThreeList.Ldata.Subl1()
e_11.number = 311
e_11.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
e_12.number = 312
e_12.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
e_111 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_112 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_111.number = 3111
e_111.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:subsubl1[' + str(
e_111.number) + ']:name'
e_112.number = 3112
e_112.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:subsubl1[' + str(
e_112.number) + ']:name'
e_11.sub_subl1.extend([e_111, e_112])
e_121 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_122 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_121.number = 3121
e_121.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:subsubl1[' + str(
e_121.number) + ']:name'
e_122.number = 3122
e_121.name = 'runner:threelist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:subsubl1[' + str(
e_122.number) + ']:name'
e_12.sub_subl1.extend([e_121, e_122])
e_1.subl1.extend([e_11, e_12])
e_21 = Runner.ThreeList.Ldata.Subl1()
e_22 = Runner.ThreeList.Ldata.Subl1()
e_21.number = 321
e_21.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
e_22.number = 322
e_22.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
e_211 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_212 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_211.number = 3211
e_211.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:subsubl1[' + str(
e_211.number) + ']:name'
e_212.number = 3212
e_212.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:subsubl1[' + str(
e_212.number) + ']:name'
e_21.sub_subl1.extend([e_211, e_212])
e_221 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_222 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_221.number = 3221
e_221.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:subsubl1[' + str(
e_221.number) + ']:name'
e_222.number = 3222
e_222.name = 'runner:threelist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:subsubl1[' + str(
e_222.number) + ']:name'
e_22.sub_subl1.extend([e_221, e_222])
e_2.subl1.extend([e_21, e_22])
r_1.three_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DEEPCOPY
r_1_copy = copy.deepcopy(r_1)
self.assertEqual(is_equal(r_1_copy, r_1), True)
self.crud.create(self.ncc, r_1_copy)
r_2_copy = self.crud.read(self.ncc, Runner())
self.assertEqual(is_equal(r_2_copy, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.ThreeList.Ldata()
e_1.number = 31
e_1.name = 'runner/threelist/ldata[' + str(e_1.number) + ']/name'
e_2 = Runner.ThreeList.Ldata()
e_2.number = 32
e_2.name = 'runner/threelist/ldata[' + str(e_2.number) + ']/name'
e_11 = Runner.ThreeList.Ldata.Subl1()
e_12 = Runner.ThreeList.Ldata.Subl1()
e_11.number = 311
e_11.name = 'runner/threelistldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/name'
e_12.number = 312
e_12.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/name'
e_111 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_112 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_111.number = 3111
e_111.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/subsubl1[' + str(
e_111.number) + ']/name'
e_112.number = 3112
e_112.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_11.number) + ']/subsubl1[' + str(
e_112.number) + ']/name'
e_11.sub_subl1.extend([e_111, e_112])
e_121 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_122 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_121.number = 3121
e_121.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/subsubl1[' + str(
e_121.number) + ']/name'
e_122.number = 3122
e_121.name = 'runner/threelist/ldata[' + str(
e_1.number) + ']/subl1[' + str(e_12.number) + ']/subsubl1[' + str(
e_122.number) + ']/name'
e_12.sub_subl1.extend([e_121, e_122])
e_1.subl1.extend([e_11, e_12])
e_21 = Runner.ThreeList.Ldata.Subl1()
e_22 = Runner.ThreeList.Ldata.Subl1()
e_21.number = 321
e_21.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/name'
e_22.number = 322
e_22.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/name'
e_211 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_212 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_211.number = 3211
e_211.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/subsubl1[' + str(
e_211.number) + ']/name'
e_212.number = 3212
e_212.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_21.number) + ']/subsubl1[' + str(
e_212.number) + ']/name'
e_21.sub_subl1.extend([e_211, e_212])
e_221 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_222 = Runner.ThreeList.Ldata.Subl1.SubSubl1()
e_221.number = 3221
e_221.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/subsubl1[' + str(
e_221.number) + ']/name'
e_222.number = 3222
e_222.name = 'runner/threelist/ldata[' + str(
e_2.number) + ']/subl1[' + str(e_22.number) + ']/subsubl1[' + str(
e_222.number) + ']/name'
e_22.sub_subl1.extend([e_221, e_222])
e_2.subl1.extend([e_21, e_22])
r_1.three_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_InbtwList_pos(self):
# READ
r_1, r_2 = Runner(), Runner()
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner:inbtwlist:[' + str(e_1.number) + ']:name'
e_1.subc.number = 111
e_1.subc.name = 'runner:inbtwlist:[' + str(e_1.number) + ']:subc:name'
e_2.number = 12
e_2.name = 'runner:inbtwlist:[' + str(e_2.number) + ']:name'
e_2.subc.number = 121
e_2.subc.name = 'runner:inbtwlist:[' + str(e_2.number) + ']:name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner:inbtwlist:[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_11.number) + ']:name'
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner:inbtwlist:[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_12.number) + ']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner:inbtwlist:[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_21.number) + ']:name'
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner:inbtwlist:[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_22.number) + ']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_1.name = 'runner/inbtwlist/[' + str(e_1.number) + ']/name'
e_1.subc.number = 111
e_1.subc.name = 'runnerinbtwlist/[' + str(e_1.number) + ']/subc/name'
e_2.number = 12
e_2.name = 'runner/inbtwlist/[' + str(e_2.number) + ']/name'
e_2.subc.number = 121
e_2.subc.name = 'runner/inbtwlist/[' + str(e_2.number) + ']/name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_11.name = 'runner/inbtwlist/[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_11.number) + ']/name'
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12.number = 112
e_12.name = 'runner/inbtwlist/[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_12.number) + ']/name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 121
e_21.name = 'runner/inbtwlist/[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_21.number) + ']/name'
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22.number = 122
e_22.name = 'runner/inbtwlist/[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_22.number) + ']/name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_leafref_simple_pos(self):
# change ref and original data together
# READ
r_1, r_2 = Runner(), Runner()
r_1.ytypes.built_in_t.number8 = 100
r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.ytypes.built_in_t.number8 = 110
r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_leafref_pos(self):
# rfc: refer to leaf
# 1.already exists
# 2.has default value
# create leafs will be referred to
# CREATE
r_1, r_2 = Runner(), Runner()
r_1.one.name = 'runner:one:name'
r_1.two.sub1.number = 21
r_1.three.sub1.sub2.number = 311
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_2.number = 21
e_1.name = 'runner:inbtwlist[' + str(e_1.number) + ']:name'
e_2.name = 'runner:inbtwlist[' + str(e_2.number) + ']:name'
e_1.subc.number = 111
e_2.subc.number = 121
e_1.subc.name = 'runner:inbtwlist[' + str(e_1.number) + ']:subc:name'
e_2.subc.name = 'runner:inbtwlist[' + str(e_2.number) + ']:subc:name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_12.number = 112
e_11.name = 'runner:inbtwlist[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_11.number) + ']:name'
e_12.name = 'runner:inbtwlist[' + str(
e_1.number) + ']:subc:subcsubl1[' + str(e_12.number) + ']:name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 311
e_22.number = 122
e_21.name = 'runner:inbtwlist[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_21.number) + ']:name'
e_22.name = 'runner:inbtwlist[' + str(
e_2.number) + ']:subc:subcsubl1[' + str(e_22.number) + ']:name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
r_1.leaf_ref.ref_one_name = r_1.one.name
r_1.leaf_ref.ref_two_sub1_number = r_1.two.sub1.number
r_1.leaf_ref.ref_three_sub1_sub2_number = r_1.three.sub1.sub2.number
r_1.leaf_ref.ref_inbtw = e_21.name
r_1.leaf_ref.one.name = 'runner:leaf-ref:one:name'
r_1.leaf_ref.one.two.self_ref_one_name = r_1.leaf_ref.ref_one_name
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_1.one.name, r_1.leaf_ref.ref_one_name)
self.assertEqual(r_1.two.sub1.number, r_1.leaf_ref.ref_two_sub1_number)
self.assertEqual(r_1.three.sub1.sub2.number,
r_1.leaf_ref.ref_three_sub1_sub2_number)
self.assertEqual(r_1.inbtw_list.ldata[1].subc.subc_subl1[0].name,
r_1.leaf_ref.ref_inbtw)
self.assertEqual(r_1.leaf_ref.ref_one_name,
r_1.leaf_ref.one.two.self_ref_one_name)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.one.name = 'runner/one/name'
r_1.two.sub1.number = 21
r_1.three.sub1.sub2.number = 311
e_1 = Runner.InbtwList.Ldata()
e_2 = Runner.InbtwList.Ldata()
e_1.number = 11
e_2.number = 21
e_1.name = 'runner/inbtwlist[' + str(e_1.number) + ']/name'
e_2.name = 'runner/inbtwlist[' + str(e_2.number) + ']/name'
e_1.subc.number = 111
e_2.subc.number = 121
e_1.subc.name = 'runner/inbtwlist[' + str(e_1.number) + ']/subc/name'
e_2.subc.name = 'runner/inbtwlist[' + str(e_2.number) + ']/subc/name'
e_11 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_12 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_11.number = 111
e_12.number = 112
e_11.name = 'runner/inbtwlist[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_11.number) + ']/name'
e_12.name = 'runner/inbtwlist[' + str(
e_1.number) + ']/subc/subcsubl1[' + str(e_12.number) + ']/name'
e_1.subc.subc_subl1.extend([e_11, e_12])
e_21 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_22 = Runner.InbtwList.Ldata.Subc.SubcSubl1()
e_21.number = 311
e_22.number = 122
e_21.name = 'runner/inbtwlist[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_21.number) + ']/name'
e_22.name = 'runner/inbtwlist[' + str(
e_2.number) + ']/subc/subcsubl1[' + str(e_22.number) + ']/name'
e_2.subc.subc_subl1.extend([e_21, e_22])
r_1.inbtw_list.ldata.extend([e_1, e_2])
r_1.leaf_ref.ref_one_name = r_1.one.name
r_1.leaf_ref.ref_two_sub1_number = r_1.two.sub1.number
r_1.leaf_ref.ref_three_sub1_sub2_number = r_1.three.sub1.sub2.number
r_1.leaf_ref.ref_inbtw = e_21.name
r_1.leaf_ref.one.name = 'runner/leaf-ref/one/name'
r_1.leaf_ref.one.two.self_ref_one_name = r_1.leaf_ref.ref_one_name
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_1.one.name, r_1.leaf_ref.ref_one_name)
self.assertEqual(r_1.two.sub1.number, r_1.leaf_ref.ref_two_sub1_number)
self.assertEqual(r_1.three.sub1.sub2.number,
r_1.leaf_ref.ref_three_sub1_sub2_number)
self.assertEqual(r_1.inbtw_list.ldata[1].subc.subc_subl1[0].name,
r_1.leaf_ref.ref_inbtw)
self.assertEqual(r_1.leaf_ref.ref_one_name,
r_1.leaf_ref.one.two.self_ref_one_name)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_aug_one_pos(self):
# CREATE
r_1, r_2 = Runner(), Runner()
r_1.one.one_aug.number = 1
r_1.one.one_aug.name = r_1.one.one_aug._common_path
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
r_1.one.one_aug.number = 10
r_1.one.one_aug.name = r_1.one.one_aug._common_path.replace(':', '/')
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_1)
self.assertEqual(r_2._has_data(), False)
def test_aug_onelist_pos(self):
# CREATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.OneList.OneAugList.Ldata()
e_2 = Runner.OneList.OneAugList.Ldata()
e_1.number = 1
e_1.name = e_1._common_path
e_2.number = 2
e_2.name = e_2._common_path
r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
r_1.one_list.one_aug_list.enabled = True
self.crud.create(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# UPDATE
r_1, r_2 = Runner(), Runner()
e_1 = Runner.OneList.OneAugList.Ldata()
e_2 = Runner.OneList.OneAugList.Ldata()
e_1.number = 1
e_1.name = e_1._common_path.replace(':', '/')
e_2.number = 2
e_2.name = e_2._common_path.replace(':', '/')
r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
r_1.one_list.one_aug_list.enabled = True
self.crud.update(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(is_equal(r_1, r_2), True)
# DELETE
r_1 = Runner()
self.crud.delete(self.ncc, r_1)
r_2 = self.crud.read(self.ncc, r_2)
self.assertEqual(r_2._has_data(), False)
def test_parent_empty(self):
runner = Runner()
runner.ytypes.enabled = Empty()
runner.ytypes.built_in_t.emptee = Empty()
self.crud.create(self.ncc, runner)
runner_read = self.crud.read(self.ncc, Runner())
self.assertEqual(is_equal(runner_read, runner), True)
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.errcode, YPYErrorCode.INVALID_RPC)
'''TODO: get-schema rpc is not yet supported on netsim
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)
