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