def test_proxy_settings_obj(self):
proxy_settings = ProxySettings(host='foo', port=1234)
os_creds = OSCreds(username='******',
password='******',
auth_url='http://foo.bar:5000/',
project_name='hello',
proxy_settings=proxy_settings)
self.assertEqual('foo', os_creds.username)
self.assertEqual('bar', os_creds.password)
self.assertEqual('http://foo.bar:5000/v3', os_creds.auth_url)
self.assertEqual('hello', os_creds.project_name)
self.assertEqual(3, os_creds.identity_api_version)
self.assertEqual(2, os_creds.image_api_version)
self.assertEqual(2, os_creds.compute_api_version)
self.assertEqual(1, os_creds.heat_api_version)
self.assertEqual(cinder_utils.VERSION_2, os_creds.volume_api_version)
self.assertEqual(1, os_creds.magnum_api_version)
self.assertEqual('default', os_creds.user_domain_id)
self.assertEqual('Default', os_creds.user_domain_name)
self.assertEqual('default', os_creds.project_domain_id)
self.assertEqual('Default', os_creds.project_domain_name)
self.assertEqual('public', os_creds.interface)
self.assertFalse(os_creds.cacert)
self.assertEqual('foo', os_creds.proxy_settings.host)
self.assertEqual('1234', os_creds.proxy_settings.port)
self.assertIsNone(os_creds.proxy_settings.ssh_proxy_cmd)
self.assertIsNone(os_creds.region_name)
creds_dict = os_creds.to_dict()
creds_from_dict = OSCreds(**creds_dict)
self.assertEqual(os_creds, creds_from_dict)
def setUp(self):
self.os_creds = OSCreds(
username='******', password='******',
auth_url='http://foo.com:5000/v3', project_name='bar')
self.smoke = smoke.SnapsSmoke(
os_creds=self.os_creds, ext_net_name='foo')
def setUp(self):
self.os_creds = OSCreds(
username='******', password='******',
auth_url='http://foo.com:5000/v3', project_name='bar')
self.api_check = api_check.ApiCheck(
os_creds=self.os_creds, ext_net_name='foo')
def setUp(self):
self.os_creds = OSCreds(username='******',
password='******',
auth_url='http://foo.com:5000/v3',
project_name='bar')
self.vping_ssh = vping_ssh.VPingSSH(os_creds=self.os_creds)
def prepare(self):
super(CloudifyVrouter, self).prepare()
self.__logger.info("Additional pre-configuration steps")
self.snaps_creds = OSCreds(username=self.creds['username'],
password=self.creds['password'],
auth_url=self.creds['auth_url'],
project_name=self.creds['tenant'],
identity_api_version=int(
os_utils.get_keystone_client_version()))
self.util.set_credentials(self.creds["username"],
self.creds["password"],
self.creds["auth_url"], self.creds["tenant"])
# needs some images
self.__logger.info("Upload some OS images if it doesn't exist")
for image_name, image_file in self.images.iteritems():
self.__logger.info("image: %s, file: %s", image_name, image_file)
if image_file and image_name:
image_creator = OpenStackImage(
self.snaps_creds,
ImageSettings(name=image_name,
image_user='******',
img_format='qcow2',
image_file=image_file))
image_creator.create()
self.created_object.append(image_creator)
def prepare(self):
"""Prepare testscase (Additional pre-configuration steps)."""
super(CloudifyIms, self).prepare()
self.__logger.info("Additional pre-configuration steps")
self.snaps_creds = OSCreds(
username=self.creds['username'],
password=self.creds['password'],
auth_url=self.creds['auth_url'],
project_name=self.creds['tenant'],
identity_api_version=int(os_utils.get_keystone_client_version()))
# needs some images
self.__logger.info("Upload some OS images if it doesn't exist")
for image_name, image_url in self.images.iteritems():
self.__logger.info("image: %s, url: %s", image_name, image_url)
if image_url and image_name:
image_creator = OpenStackImage(
self.snaps_creds,
ImageSettings(name=image_name,
image_user='******',
img_format='qcow2',
url=image_url))
image_creator.create()
def test_prepare_bad_auth_url(self, *args):
with self.assertRaises(Exception):
self.router_vnf.image_creator(
OSCreds(username='******', password='******', auth_url='url',
project_name='project', identity_api_version=3),
mock.Mock())
args[0].assert_not_called()
def setUp(self):
os_creds = OSCreds(
username='******', password='******',
auth_url='http://foo.com:5000/v3', project_name='bar')
with mock.patch('functest.opnfv_tests.openstack.tempest.tempest.'
'conf_utils.get_verifier_id',
return_value='test_deploy_id'), \
mock.patch('functest.opnfv_tests.openstack.tempest.tempest.'
'conf_utils.get_verifier_deployment_id',
return_value='test_deploy_id'), \
mock.patch('functest.opnfv_tests.openstack.tempest.tempest.'
'conf_utils.get_verifier_repo_dir',
return_value='test_verifier_repo_dir'), \
mock.patch('functest.opnfv_tests.openstack.tempest.tempest.'
'conf_utils.get_verifier_deployment_dir',
return_value='test_verifier_deploy_dir'), \
mock.patch('snaps.openstack.tests.openstack_tests.get_credentials',
return_value=os_creds):
self.tempestcommon = tempest.TempestCommon()
self.tempestsmoke_serial = tempest.TempestSmokeSerial()
self.tempestsmoke_parallel = tempest.TempestSmokeParallel()
self.tempestfull_parallel = tempest.TempestFullParallel()
self.tempestcustom = tempest.TempestCustom()
self.tempestdefcore = tempest.TempestDefcore()
def test_proxy_settings_dict_kwargs(self):
os_creds = OSCreds(
**{
'username': '******',
'password': '******',
'auth_url': 'http://foo.bar:5000/v2',
'project_name': 'hello',
'proxy_settings': {
'host': 'foo',
'port': 1234
},
'region_name': 'test_region'
})
self.assertEqual('foo', os_creds.username)
self.assertEqual('bar', os_creds.password)
self.assertEqual('http://foo.bar:5000/v3', os_creds.auth_url)
self.assertEqual('hello', os_creds.project_name)
self.assertEqual(3, os_creds.identity_api_version)
self.assertEqual(2, os_creds.image_api_version)
self.assertEqual(2, os_creds.compute_api_version)
self.assertEqual(1, os_creds.heat_api_version)
self.assertEqual(cinder_utils.VERSION_2, os_creds.volume_api_version)
self.assertEqual(1, os_creds.magnum_api_version)
self.assertEqual('default', os_creds.user_domain_id)
self.assertEqual('Default', os_creds.user_domain_name)
self.assertEqual('default', os_creds.project_domain_id)
self.assertEqual('Default', os_creds.project_domain_name)
self.assertEqual('public', os_creds.interface)
self.assertFalse(os_creds.cacert)
self.assertEqual('foo', os_creds.proxy_settings.host)
self.assertEqual('1234', os_creds.proxy_settings.port)
self.assertIsNone(os_creds.proxy_settings.ssh_proxy_cmd)
self.assertEqual('test_region', os_creds.region_name)
def test_proxy_settings_dict(self):
os_creds = OSCreds(username='******',
password='******',
auth_url='http://foo.bar:5000/v2',
project_name='hello',
proxy_settings={
'host': 'foo',
'port': 1234
},
user_domain_id='domain1',
user_domain_name='domain2',
project_domain_id='domain3',
project_domain_name='domain4')
self.assertEqual('foo', os_creds.username)
self.assertEqual('bar', os_creds.password)
self.assertEqual('http://foo.bar:5000/v3', os_creds.auth_url)
self.assertEqual('hello', os_creds.project_name)
self.assertEqual(3, os_creds.identity_api_version)
self.assertEqual(2, os_creds.image_api_version)
self.assertEqual(2, os_creds.compute_api_version)
self.assertEqual(1, os_creds.heat_api_version)
self.assertEqual(cinder_utils.VERSION_2, os_creds.volume_api_version)
self.assertEqual(1, os_creds.magnum_api_version)
self.assertEqual('domain1', os_creds.user_domain_id)
self.assertEqual('domain2', os_creds.user_domain_name)
self.assertEqual('domain3', os_creds.project_domain_id)
self.assertEqual('domain4', os_creds.project_domain_name)
self.assertEqual('public', os_creds.interface)
self.assertFalse(os_creds.cacert)
self.assertEqual('foo', os_creds.proxy_settings.host)
self.assertEqual('1234', os_creds.proxy_settings.port)
self.assertIsNone(os_creds.proxy_settings.ssh_proxy_cmd)
def test_all_kwargs_versions_num(self):
os_creds = OSCreds(
**{
'username': '******',
'password': '******',
'auth_url': 'http://foo.bar:5000/v2',
'project_name': 'hello',
'identity_api_version': 5,
'image_api_version': 6,
'compute_api_version': 7,
'heat_api_version': 8.0,
'volume_api_version': 9.5,
'magnum_api_version': 10.6,
'cacert': True,
'region_name': 'test_region'
})
self.assertEqual('foo', os_creds.username)
self.assertEqual('bar', os_creds.password)
self.assertEqual('http://foo.bar:5000/v5', os_creds.auth_url)
self.assertEqual('hello', os_creds.project_name)
self.assertEqual(5, os_creds.identity_api_version)
self.assertEqual(6, os_creds.image_api_version)
self.assertEqual(7, os_creds.compute_api_version)
self.assertEqual(8.0, os_creds.heat_api_version)
self.assertEqual(9.5, os_creds.volume_api_version)
self.assertEqual(10.6, os_creds.magnum_api_version)
self.assertEqual('default', os_creds.user_domain_id)
self.assertEqual('Default', os_creds.user_domain_name)
self.assertEqual('default', os_creds.project_domain_id)
self.assertEqual('Default', os_creds.project_domain_name)
self.assertEqual('public', os_creds.interface)
self.assertTrue(os_creds.cacert)
self.assertIsNone(os_creds.proxy_settings)
self.assertEqual('test_region', os_creds.region_name)
def __reboot_openstack_node(vm_info):
creds_dict = vm_info.get('os_creds')
os_creds = OSCreds(**creds_dict)
logger.debug('Retrieving keystone session %s', creds_dict)
os_sess = keystone_utils.keystone_session(os_creds)
try:
logger.debug('Retrieving OpenStack clients with %s', creds_dict)
nova = nova_utils.nova_client(os_creds, os_sess)
neutron = neutron_utils.neutron_client(os_creds, os_sess)
keystone = keystone_utils.keystone_client(os_creds, os_sess)
logger.info('Retrieved OpenStack clients')
vm_inst = nova_utils.get_server_object_by_id(nova, neutron, keystone,
vm_info['id'])
logger.info('Looking up VM named [%s]', vm_inst.name)
if vm_inst:
logger.debug('Generating VM SNAPS creator with creds [%s]',
creds_dict)
snaps_vm = create_instance.generate_creator(
os_creds, vm_inst, None, os_creds.project_name)
if snaps_vm:
logger.info('Rebooting VM with name %s', vm_inst.name)
snaps_vm.reboot(RebootType.hard)
else:
logger.warn('Unable to obtain a SNAPS-OO VM creator [%s]',
vm_inst.name)
else:
logger.warn('Unable to locate VM with name %s', vm_inst.name)
finally:
logger.info('Closing keystone session')
keystone_utils.close_session(os_sess)
def __get_os_credentials(os_conn_config):
"""
Returns an object containing all of the information required to access
OpenStack APIs
:param os_conn_config: The configuration holding the credentials
:return: an OSCreds instance
"""
config = os_conn_config.get('connection')
if not config:
raise Exception('Invalid connection configuration')
proxy_settings = None
http_proxy = config.get('http_proxy')
if http_proxy:
tokens = re.split(':', http_proxy)
ssh_proxy_cmd = config.get('ssh_proxy_cmd')
proxy_settings = ProxySettings(host=tokens[0], port=tokens[1],
ssh_proxy_cmd=ssh_proxy_cmd)
else:
if 'proxy_settings' in config:
host = config['proxy_settings'].get('host')
port = config['proxy_settings'].get('port')
if host and host != 'None' and port and port != 'None':
proxy_settings = ProxySettings(**config['proxy_settings'])
if proxy_settings:
config['proxy_settings'] = proxy_settings
else:
if config.get('proxy_settings'):
del config['proxy_settings']
return OSCreds(**config)
def get_os_creds(self, project_name=None):
"""
Returns an OSCreds object based on this user account and a project
:param project_name: the name of the project to leverage in the
credentials
:return:
"""
if not project_name:
project_name = self._os_creds.project_name
return OSCreds(
username=self.user_settings.name,
password=self.user_settings.password,
auth_url=self._os_creds.auth_url,
project_name=project_name,
identity_api_version=self._os_creds.identity_api_version,
image_api_version=self._os_creds.image_api_version,
network_api_version=self._os_creds.network_api_version,
compute_api_version=self._os_creds.compute_api_version,
heat_api_version=self._os_creds.heat_api_version,
volume_api_version=self._os_creds.volume_api_version,
region_name=self._os_creds.region_name,
user_domain_name=self._os_creds.user_domain_name,
user_domain_id=self._os_creds.user_domain_id,
project_domain_name=self._os_creds.project_domain_name,
project_domain_id=self._os_creds.project_domain_id,
interface=self._os_creds.interface,
proxy_settings=self._os_creds.proxy_settings,
cacert=self._os_creds.cacert)
def setUp(self):
self.default_args = {'config': self._config,
'testlist': self._testlist}
CONST.__setattr__('OS_AUTH_URL', 'https://ip:5000/v3')
CONST.__setattr__('OS_INSECURE', 'true')
self.os_creds = OSCreds(
username='******', password='******',
auth_url='http://foo.com:5000/v3', project_name='bar')
def prepare(self):
"""Prepare testcase (Additional pre-configuration steps)."""
self.__logger.debug("OS Credentials: %s", os_utils.get_credentials())
super(JujuEpc, self).prepare()
self.__logger.info("Additional pre-configuration steps")
self.public_auth_url = keystone_utils.get_endpoint(
self.snaps_creds, 'identity')
# it enforces a versioned public identity endpoint as juju simply
# adds /auth/tokens wich fails vs an unversioned endpoint.
if not self.public_auth_url.endswith(('v3', 'v3/', 'v2.0', 'v2.0/')):
self.public_auth_url = urljoin(self.public_auth_url, 'v3')
self.creds = {
"tenant": self.tenant_name,
"username": self.tenant_name,
"password": self.tenant_name,
"auth_url": os_utils.get_credentials()['auth_url']
}
self.snaps_creds = OSCreds(
username=self.creds['username'],
password=self.creds['password'],
auth_url=self.creds['auth_url'],
project_name=self.creds['tenant'],
identity_api_version=int(os_utils.get_keystone_client_version()))
cloud_data = {
'url': self.public_auth_url,
'pass': self.tenant_name,
'tenant_n': self.tenant_name,
'user_n': self.tenant_name,
'region': os.environ.get(
"OS_REGION_NAME", self.default_region_name)
}
self.__logger.info("Cloud DATA: %s", cloud_data)
self.filename = os.path.join(self.case_dir, 'abot-epc.yaml')
self.__logger.info("Create %s to add cloud info", self.filename)
write_config(self.filename, CLOUD_TEMPLATE, **cloud_data)
if self.snaps_creds.identity_api_version == 3:
append_config(self.filename, '{}'.format(
os_utils.get_credentials()['project_domain_name']),
'{}'.format(os_utils.get_credentials()['user_domain_name']))
self.__logger.info("Upload some OS images if it doesn't exist")
for image_name, image_file in self.images.iteritems():
self.__logger.info("image: %s, file: %s", image_name, image_file)
if image_file and image_name:
image_creator = OpenStackImage(
self.snaps_creds,
ImageSettings(name=image_name,
image_user='******',
img_format='qcow2',
image_file=image_file))
image_creator.create()
self.created_object.append(image_creator)
def setUp(self):
os_creds = OSCreds(
username='******', password='******',
auth_url='http://foo.com:5000/v3', project_name='bar')
with mock.patch('snaps.openstack.tests.openstack_tests.'
'get_credentials', return_value=os_creds) as m:
self.rally_base = rally.RallyBase()
self.polling_iter = 2
self.assertTrue(m.called)
def setUp(self):
os_creds = OSCreds(
username='******', password='******',
auth_url='http://foo.com:5000/v3', project_name='bar')
with mock.patch('functest.opnfv_tests.openstack.snaps.snaps_utils.'
'get_credentials',
return_value=os_creds) as mock_get_creds:
self.rally_base = rally.RallyBase()
self.assertTrue(mock_get_creds.called)
def test_cinder_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
from snaps.openstack.os_credentials import OSCreds
with self.assertRaises(Exception):
cinder = cinder_utils.cinder_client(OSCreds(
username='******', password='******', auth_url='url',
project_name='project'))
cinder.volumes.list()
def test_nova_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
with self.assertRaises(RuntimeError):
magnum_utils.magnum_client(
OSCreds(username='******', password='******',
auth_url=self.os_creds.auth_url,
project_name=self.os_creds.project_name,
proxy_settings=self.os_creds.proxy_settings))
def test_glance_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
from snaps.openstack.os_credentials import OSCreds
with self.assertRaises(Exception):
glance = glance_utils.glance_client(
OSCreds(username='******',
password='******',
auth_url='url',
project_name='project'))
glance_utils.get_image(glance, image_name='foo')
def test_get_endpoint_fail_without_proper_credentials(self):
"""
Tests to ensure that improper credentials and proper service type
cannot succeed.
"""
from snaps.openstack.os_credentials import OSCreds
with self.assertRaises(Exception):
keystone_utils.get_endpoint(OSCreds(username='******',
password='******',
auth_url='url',
project_name='project'),
service_type='image')
def setUp(self):
self.os_creds = OSCreds(username='******',
password='******',
auth_url='http://foo.com:5000/v3',
project_name='bar')
with mock.patch('os_client_config.get_config') as mock_get_config, \
mock.patch('shade.OpenStackCloud') as mock_shade, \
mock.patch('functest.core.tenantnetwork.NewProject') \
as mock_new_project:
self.api_check = api_check.ApiCheck(os_creds=self.os_creds,
ext_net_name='foo')
mock_get_config.assert_called()
mock_shade.assert_called()
mock_new_project.assert_called()
def test_nova_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
from snaps.openstack.os_credentials import OSCreds
nova = nova_utils.nova_client(
OSCreds(username='******', password='******',
auth_url=self.os_creds.auth_url,
project_name=self.os_creds.project_name,
proxy_settings=self.os_creds.proxy_settings))
# This should throw an exception
with self.assertRaises(Exception):
nova.flavors.list()
def prepare(self):
"""Prepare testcase (Additional pre-configuration steps)."""
self.__logger.debug("OS Credentials: %s", os_utils.get_credentials())
super(JujuEpc, self).prepare()
self.__logger.info("Additional pre-configuration steps")
self.creds = {
"tenant": self.tenant_name,
"username": self.tenant_name,
"password": self.tenant_name,
"auth_url": os_utils.get_credentials()['auth_url']
}
self.snaps_creds = OSCreds(
username=self.creds['username'],
password=self.creds['password'],
auth_url=self.creds['auth_url'],
project_name=self.creds['tenant'],
identity_api_version=int(os_utils.get_keystone_client_version()))
cmd = "sed -i 's#endpoint:.*#endpoint: {}#g' {}/abot_epc_\
cloud.yaml".format(self.creds['auth_url'], self.case_dir)
os.system(cmd)
if self.snaps_creds.identity_api_version == 3:
cmd = "sed -i '/username/a\ user-domain-name: {}' {}/abot_" \
"epc_credential.yaml".format(os_utils.get_credentials()
['user_domain_name'],
self.case_dir)
os.system(cmd)
cmd = "sed -i '/username/a\ project-domain-name: {}' {}" \
"/abot_epc_credential.yaml".format(os_utils.get_credentials()
['project_domain_name'],
self.case_dir)
os.system(cmd)
self.__logger.info("Upload some OS images if it doesn't exist")
for image_name, image_file in self.images.iteritems():
self.__logger.info("image: %s, file: %s", image_name, image_file)
if image_file and image_name:
image_creator = OpenStackImage(
self.snaps_creds,
ImageSettings(name=image_name,
image_user='******',
img_format='qcow2',
image_file=image_file))
image_creator.create()
self.created_object.append(image_creator)
def test_heat_connect_fail(self):
"""
Tests to ensure that the improper credentials cannot connect.
"""
from snaps.openstack.os_credentials import OSCreds
heat = heat_utils.heat_client(
OSCreds(username='******',
password='******',
auth_url=self.os_creds.auth_url,
project_name=self.os_creds.project_name,
proxy_settings=self.os_creds.proxy_settings))
stacks = heat.stacks.list()
# This should throw an exception
with self.assertRaises(Exception):
for stack in stacks:
logger.info('Stack - %s', stack)
def prepare(self):
"""Prepare testscase (Additional pre-configuration steps)."""
super(ClearwaterImsVnf, self).prepare()
self.logger.info("Additional pre-configuration steps")
self.logger.info("creds %s", (self.creds))
self.snaps_creds = OSCreds(username=self.creds['username'],
password=self.creds['password'],
auth_url=self.creds['auth_url'],
project_name=self.creds['tenant'],
identity_api_version=int(
os_utils.get_keystone_client_version()))
self.prepare_images()
self.prepare_flavor()
self.prepare_security_groups()
self.prepare_network()
self.prepare_floating_ip()
def setUp(self):
self.default_args = {
'config': self._config,
'testlist': self._testlist
}
CONST.__setattr__('OS_AUTH_URL', 'https://ip:5000/v3')
CONST.__setattr__('OS_INSECURE', 'true')
self.case_name = 'refstack_defcore'
self.result = 0
self.os_creds = OSCreds(username='******',
password='******',
auth_url='http://foo.com:5000/v3',
project_name='bar')
self.details = {
"tests": 3,
"failures": 1,
"success": ['tempest.api.compute [18.464988s]'],
"errors": ['tempest.api.volume [0.230334s]'],
"skipped": ['tempest.api.network [1.265828s]']
}
def test_minimal(self):
os_creds = OSCreds(username='******',
password='******',
auth_url='http://foo.bar:5000/v2',
project_name='hello')
self.assertEqual('foo', os_creds.username)
self.assertEqual('bar', os_creds.password)
self.assertEqual('http://foo.bar:5000/v3', os_creds.auth_url)
self.assertEqual('hello', os_creds.project_name)
self.assertEqual(3, os_creds.identity_api_version)
self.assertEqual(2, os_creds.image_api_version)
self.assertEqual(2, os_creds.compute_api_version)
self.assertEqual(1, os_creds.heat_api_version)
self.assertEqual(cinder_utils.VERSION_2, os_creds.volume_api_version)
self.assertEqual(1, os_creds.magnum_api_version)
self.assertEqual('default', os_creds.user_domain_id)
self.assertEqual('Default', os_creds.user_domain_name)
self.assertEqual('default', os_creds.project_domain_id)
self.assertEqual('Default', os_creds.project_domain_name)
self.assertEqual('public', os_creds.interface)
self.assertFalse(os_creds.cacert)
self.assertIsNone(os_creds.proxy_settings)
self.assertIsNone(os_creds.region_name)
def setUp(self):
self.os_creds = OSCreds(username='******',
password='******',
auth_url='http://foo.com:5000/v3',
project_name='bar')