def test__parse_driver_info_missing_host(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info()
del info['ssh_address']
node = db_utils.get_test_node(driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def test__parse_driver_info_invalid_creds(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info('no-creds')
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info,
node)
def setUp(self):
super(SSHPrivateMethodsTestCase, self).setUp()
self.node = obj_utils.get_test_node(
self.context,
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.sshclient = paramiko.SSHClient()
def setUp(self):
super(SSHDriverTestCase, self).setUp()
self.context = context.get_admin_context()
mgr_utils.mock_the_extension_manager(driver="fake_ssh")
self.driver = driver_factory.get_driver("fake_ssh")
n = db_utils.get_test_node(
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.dbapi = dbapi.get_instance()
self.node = self.dbapi.create_node(n)
self.port = self.dbapi.create_port(db_utils.get_test_port(
node_id=self.node.id))
self.sshclient = paramiko.SSHClient()
#setup these mocks because most tests use them
self.parse_drv_info_patcher = mock.patch.object(ssh,
'_parse_driver_info')
self.parse_drv_info_mock = None
self.get_mac_addr_patcher = mock.patch.object(
ssh,
'_get_nodes_mac_addresses')
self.get_mac_addr_mock = self.get_mac_addr_patcher.start()
self.get_conn_patcher = mock.patch.object(ssh, '_get_connection')
self.get_conn_mock = self.get_conn_patcher.start()
def stop_patchers():
if self.parse_drv_info_mock:
self.parse_drv_info_patcher.stop()
if self.get_mac_addr_mock:
self.get_mac_addr_patcher.stop()
if self.get_conn_mock:
self.get_conn_patcher.stop()
self.addCleanup(stop_patchers)
def test__parse_driver_info_too_many(self):
info = db_utils.get_test_ssh_info('too_many')
node = obj_utils.get_test_node(self.context,
driver='fake_ssh',
driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def setUp(self):
super(SSHDriverTestCase, self).setUp()
self.context = context.get_admin_context()
mgr_utils.mock_the_extension_manager(driver="fake_ssh")
self.driver = driver_factory.get_driver("fake_ssh")
n = db_utils.get_test_node(driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.dbapi = dbapi.get_instance()
self.node = self.dbapi.create_node(n)
self.port = self.dbapi.create_port(
db_utils.get_test_port(node_id=self.node.id))
self.sshclient = paramiko.SSHClient()
#setup these mocks because most tests use them
self.parse_drv_info_patcher = mock.patch.object(
ssh, '_parse_driver_info')
self.parse_drv_info_mock = None
self.get_mac_addr_patcher = mock.patch.object(
ssh, '_get_nodes_mac_addresses')
self.get_mac_addr_mock = self.get_mac_addr_patcher.start()
self.get_conn_patcher = mock.patch.object(ssh, '_get_connection')
self.get_conn_mock = self.get_conn_patcher.start()
def stop_patchers():
if self.parse_drv_info_mock:
self.parse_drv_info_patcher.stop()
if self.get_mac_addr_mock:
self.get_mac_addr_patcher.stop()
if self.get_conn_mock:
self.get_conn_patcher.stop()
self.addCleanup(stop_patchers)
def test__parse_driver_info_missing_virt_type(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info()
del info['ssh_virt_type']
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def test__parse_driver_info_ssh_port_wrong_type(self):
# make sure error is raised when ssh_port is not integer
info = db_utils.get_test_ssh_info()
info['ssh_port'] = 'wrong_port_value'
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def test__parse_driver_info_invalid_creds(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info('no-creds')
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info,
node)
def setUp(self):
super(SSHPrivateMethodsTestCase, self).setUp()
self.node = obj_utils.get_test_node(
self.context,
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.sshclient = paramiko.SSHClient()
def test__parse_driver_info_with_custom_libvirt_uri(self):
CONF.set_override("libvirt_uri", "qemu:///foo", "ssh")
expected_base_cmd = "LC_ALL=C /usr/bin/virsh --connect qemu:///foo"
node = obj_utils.get_test_node(self.context, driver="fake_ssh", driver_info=db_utils.get_test_ssh_info())
node["driver_info"]["ssh_virt_type"] = "virsh"
info = ssh._parse_driver_info(node)
self.assertEqual(expected_base_cmd, info["cmd_set"]["base_cmd"])
def test__parse_driver_info_missing_user(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info()
del info['ssh_username']
node = db_utils.get_test_node(driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info,
node)
def test__parse_driver_info_too_many(self):
info = db_utils.get_test_ssh_info('too_many')
node = obj_utils.get_test_node(
self.context,
driver='fake_ssh',
driver_info=info)
self.assertRaises(
exception.InvalidParameterValue, ssh._parse_driver_info, node)
def test__parse_driver_info_bad_file(self):
# A filename that doesn't exist errors.
info = db_utils.get_test_ssh_info('file')
node = obj_utils.get_test_node(self.context,
driver='fake_ssh',
driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info, node)
def test__parse_driver_info_missing_virt_type(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info()
del info['ssh_virt_type']
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.MissingParameterValue,
ssh._parse_driver_info,
node)
def test__parse_driver_info_ssh_port_wrong_type(self):
# make sure error is raised when ssh_port is not integer
info = db_utils.get_test_ssh_info()
info['ssh_port'] = 'wrong_port_value'
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue,
ssh._parse_driver_info,
node)
def test__parse_driver_info_with_custom_libvirt_uri(self):
CONF.set_override('libvirt_uri', 'qemu:///foo', 'ssh')
expected_base_cmd = "/usr/bin/virsh --connect qemu:///foo"
node = db_utils.get_test_node(driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
node['driver_info']['ssh_virt_type'] = 'virsh'
info = ssh._parse_driver_info(node)
self.assertEqual(expected_base_cmd, info['cmd_set']['base_cmd'])
def test__parse_driver_info_bad_file(self):
# A filename that doesn't exist errors.
info = db_utils.get_test_ssh_info('file')
node = obj_utils.get_test_node(
self.context,
driver='fake_ssh',
driver_info=info)
self.assertRaises(
exception.InvalidParameterValue, ssh._parse_driver_info, node)
def test_validate_fail_no_port(self):
new_node = obj_utils.create_test_node(
self.context,
uuid="aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
driver="fake_ssh",
driver_info=db_utils.get_test_ssh_info(),
)
with task_manager.acquire(self.context, new_node.uuid, shared=True) as task:
self.assertRaises(exception.MissingParameterValue, task.driver.power.validate, task)
def setUp(self):
super(SSHDriverTestCase, self).setUp()
mgr_utils.mock_the_extension_manager(driver="fake_ssh")
self.driver = driver_factory.get_driver("fake_ssh")
self.node = obj_utils.create_test_node(
self.context, driver="fake_ssh", driver_info=db_utils.get_test_ssh_info()
)
self.port = obj_utils.create_test_port(self.context, node_id=self.node.id)
self.sshclient = paramiko.SSHClient()
def test__parse_driver_info_with_custom_libvirt_uri(self):
CONF.set_override('libvirt_uri', 'qemu:///foo', 'ssh')
expected_base_cmd = "/usr/bin/virsh --connect qemu:///foo"
node = db_utils.get_test_node(
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
node['driver_info']['ssh_virt_type'] = 'virsh'
info = ssh._parse_driver_info(node)
self.assertEqual(expected_base_cmd, info['cmd_set']['base_cmd'])
def test_validate_fail_no_port(self):
new_node = obj_utils.create_test_node(
self.context,
uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
with task_manager.acquire(self.context, new_node.uuid,
shared=True) as task:
self.assertRaises(exception.MissingParameterValue,
task.driver.power.validate, task)
def setUp(self):
super(SSHDriverTestCase, self).setUp()
mgr_utils.mock_the_extension_manager(driver="fake_ssh")
self.driver = driver_factory.get_driver("fake_ssh")
self.node = obj_utils.create_test_node(
self.context, driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
self.sshclient = paramiko.SSHClient()
def test__parse_driver_info_good_key(self):
# make sure we get back the expected things
node = obj_utils.get_test_node(self.context, driver="fake_ssh", driver_info=db_utils.get_test_ssh_info("key"))
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get("host"))
self.assertIsNotNone(info.get("username"))
self.assertIsNotNone(info.get("key_contents"))
self.assertIsNotNone(info.get("port"))
self.assertIsNotNone(info.get("virt_type"))
self.assertIsNotNone(info.get("cmd_set"))
self.assertIsNotNone(info.get("uuid"))
def test_validate_fail_no_port(self):
new_node = obj_utils.create_test_node(
self.context,
id=321,
uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
with task_manager.acquire(self.context, [new_node.uuid],
shared=True) as task:
self.assertRaises(exception.InvalidParameterValue,
task.resources[0].driver.power.validate,
task, new_node)
def test__parse_driver_info_good_key(self):
# make sure we get back the expected things
node = db_utils.get_test_node(
driver='fake_ssh', driver_info=db_utils.get_test_ssh_info('key'))
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get('host'))
self.assertIsNotNone(info.get('username'))
self.assertIsNotNone(info.get('key_contents'))
self.assertIsNotNone(info.get('port'))
self.assertIsNotNone(info.get('virt_type'))
self.assertIsNotNone(info.get('cmd_set'))
self.assertIsNotNone(info.get('uuid'))
def test__parse_driver_info_good_key(self):
# make sure we get back the expected things
node = db_utils.get_test_node(
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info('key'))
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get('host'))
self.assertIsNotNone(info.get('username'))
self.assertIsNotNone(info.get('key_contents'))
self.assertIsNotNone(info.get('port'))
self.assertIsNotNone(info.get('virt_type'))
self.assertIsNotNone(info.get('cmd_set'))
self.assertIsNotNone(info.get('uuid'))
def test_validate_fail_no_port(self):
# stop the get_mac_addr mock, it's needed for this test
self.get_mac_addr_patcher.stop()
self.get_mac_addr_mock = None
new_node = self.dbapi.create_node(db_utils.get_test_node(id=321,
uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info()))
with task_manager.acquire(self.context, [new_node.uuid],
shared=True) as task:
self.assertRaises(exception.InvalidParameterValue,
task.resources[0].driver.power.validate,
task, new_node)
def test_validate_fail_no_port(self):
# stop the get_mac_addr mock, it's needed for this test
self.get_mac_addr_patcher.stop()
self.get_mac_addr_mock = None
new_node = self.dbapi.create_node(
db_utils.get_test_node(id=321,
uuid='aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info()))
with task_manager.acquire(self.context, [new_node.uuid],
shared=True) as task:
self.assertRaises(exception.InvalidParameterValue,
task.resources[0].driver.power.validate, task,
new_node)
def test__parse_driver_info_good_file(self):
# make sure we get back the expected things
d_info = db_utils.get_test_ssh_info('file')
tempdir = self.useFixture(fixtures.TempDir())
key_path = tempdir.path + '/foo'
open(key_path, 'wt').close()
d_info['ssh_key_filename'] = key_path
node = db_utils.get_test_node(driver='fake_ssh', driver_info=d_info)
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get('host'))
self.assertIsNotNone(info.get('username'))
self.assertIsNotNone(info.get('key_filename'))
self.assertIsNotNone(info.get('port'))
self.assertIsNotNone(info.get('virt_type'))
self.assertIsNotNone(info.get('cmd_set'))
self.assertIsNotNone(info.get('uuid'))
def test__parse_driver_info_good_file(self):
# make sure we get back the expected things
d_info = db_utils.get_test_ssh_info("file")
tempdir = self.useFixture(fixtures.TempDir())
key_path = tempdir.path + "/foo"
open(key_path, "wt").close()
d_info["ssh_key_filename"] = key_path
node = obj_utils.get_test_node(self.context, driver="fake_ssh", driver_info=d_info)
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get("host"))
self.assertIsNotNone(info.get("username"))
self.assertIsNotNone(info.get("key_filename"))
self.assertIsNotNone(info.get("port"))
self.assertIsNotNone(info.get("virt_type"))
self.assertIsNotNone(info.get("cmd_set"))
self.assertIsNotNone(info.get("uuid"))
def test__parse_driver_info_good_file(self):
# make sure we get back the expected things
d_info = db_utils.get_test_ssh_info('file')
tempdir = self.useFixture(fixtures.TempDir())
key_path = tempdir.path + '/foo'
open(key_path, 'wt').close()
d_info['ssh_key_filename'] = key_path
node = db_utils.get_test_node(driver='fake_ssh', driver_info=d_info)
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get('host'))
self.assertIsNotNone(info.get('username'))
self.assertIsNotNone(info.get('key_filename'))
self.assertIsNotNone(info.get('port'))
self.assertIsNotNone(info.get('virt_type'))
self.assertIsNotNone(info.get('cmd_set'))
self.assertIsNotNone(info.get('uuid'))
def setUp(self):
super(SSHPrivateMethodsTestCase, self).setUp()
self.node = db_utils.get_test_node(
driver='fake_ssh', driver_info=db_utils.get_test_ssh_info())
self.sshclient = paramiko.SSHClient()
# Set up the mock for processutils.ssh_execute because most tests use
# it. processutils.ssh_execute returns (stdout, stderr).
self.ssh_patcher = mock.patch.object(processutils, 'ssh_execute')
self.exec_ssh_mock = self.ssh_patcher.start()
self.exec_ssh_mock.return_value = ('', '')
def stop_patcher():
if self.ssh_patcher:
self.ssh_patcher.stop()
self.addCleanup(stop_patcher)
def setUp(self):
super(SSHPrivateMethodsTestCase, self).setUp()
self.node = db_utils.get_test_node(
driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.sshclient = paramiko.SSHClient()
# Set up the mock for processutils.ssh_execute because most tests use
# it. processutils.ssh_execute returns (stdout, stderr).
self.ssh_patcher = mock.patch.object(processutils, 'ssh_execute')
self.exec_ssh_mock = self.ssh_patcher.start()
self.exec_ssh_mock.return_value = ('', '')
def stop_patcher():
if self.ssh_patcher:
self.ssh_patcher.stop()
self.addCleanup(stop_patcher)
from ironic.common import states
from ironic.common import utils
from ironic.conductor import task_manager
from ironic.db import api as dbapi
from ironic.drivers.modules import ssh
from ironic.openstack.common import context
from ironic.openstack.common import processutils
from ironic.tests import base
from ironic.tests.conductor import utils as mgr_utils
from ironic.tests.db import base as db_base
from ironic.tests.db import utils as db_utils
from oslo.config import cfg
CONF = cfg.CONF
INFO_DICT = db_utils.get_test_ssh_info()
class SSHValidateParametersTestCase(base.TestCase):
def test__parse_driver_info_good(self):
# make sure we get back the expected things
node = db_utils.get_test_node(driver='fake_ssh', driver_info=INFO_DICT)
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get('host'))
self.assertIsNotNone(info.get('username'))
self.assertIsNotNone(info.get('password'))
self.assertIsNotNone(info.get('port'))
self.assertIsNotNone(info.get('virt_type'))
self.assertIsNotNone(info.get('cmd_set'))
self.assertIsNotNone(info.get('uuid'))
from ironic.common import states
from ironic.common import utils
from ironic.conductor import task_manager
from ironic.db import api as dbapi
from ironic.drivers.modules import ssh
from ironic.openstack.common import context
from ironic.openstack.common import processutils
from ironic.tests import base
from ironic.tests.conductor import utils as mgr_utils
from ironic.tests.db import base as db_base
from ironic.tests.db import utils as db_utils
from oslo.config import cfg
CONF = cfg.CONF
INFO_DICT = db_utils.get_test_ssh_info()
class SSHValidateParametersTestCase(base.TestCase):
def test__parse_driver_info_good(self):
# make sure we get back the expected things
node = db_utils.get_test_node(
driver='fake_ssh',
driver_info=INFO_DICT)
info = ssh._parse_driver_info(node)
self.assertIsNotNone(info.get('host'))
self.assertIsNotNone(info.get('username'))
self.assertIsNotNone(info.get('password'))
self.assertIsNotNone(info.get('port'))
self.assertIsNotNone(info.get('virt_type'))
def test__parse_driver_info_missing_host(self):
# make sure error is raised when info is missing
info = db_utils.get_test_ssh_info()
del info["ssh_address"]
node = obj_utils.get_test_node(self.context, driver_info=info)
self.assertRaises(exception.InvalidParameterValue, ssh._parse_driver_info, node)
