if http_proxy:
tokens = re.split(':', http_proxy)
ssh_proxy_cmd = os_conn_config.get('ssh_proxy_cmd')
- proxy_settings = ProxySettings(tokens[0], tokens[1], ssh_proxy_cmd)
+ proxy_settings = ProxySettings(host=tokens[0], port=tokens[1],
+ ssh_proxy_cmd=ssh_proxy_cmd)
- return OSCreds(username=os_conn_config.get('username'),
- password=os_conn_config.get('password'),
- auth_url=os_conn_config.get('auth_url'),
- project_name=os_conn_config.get('project_name'),
- proxy_settings=proxy_settings)
+ os_conn_config['proxy_settings'] = proxy_settings
+
+ return OSCreds(**os_conn_config)
def __parse_ports_config(config):
var_config_values['value'] == 'id':
return flavor_creator.get_flavor().id
- logger.info("Returning none")
- return None
-
def main(arguments):
"""
Represents the credentials required to connect with OpenStack servers
"""
- def __init__(self, username, password, auth_url, project_name, identity_api_version=2, image_api_version=2,
- network_api_version=2, compute_api_version=2, user_domain_id='default', project_domain_id='default',
- interface="admin", proxy_settings=None, cacert=True):
+ def __init__(self, **kwargs):
"""
Constructor
:param username: The user (required)
:param password: The user's password (required)
:param auth_url: The OpenStack cloud's authorization URL (required)
:param project_name: The project/tenant name
- :param identity_api_version: The OpenStack's API version to use for Keystone clients
- :param image_api_version: The OpenStack's API version to use for Glance clients
- :param network_api_version: The OpenStack's API version to use for Neutron clients
- :param compute_api_version: The OpenStack's API version to use for Nova clients
+ :param identity_api_version: The OpenStack's API version to use for
+ Keystone clients
+ :param image_api_version: The OpenStack's API version to use for Glance
+ clients
+ :param network_api_version: The OpenStack's API version to use for
+ Neutron clients
+ :param compute_api_version: The OpenStack's API version to use for Nova
+ clients
:param user_domain_id: Used for v3 APIs
:param project_domain_id: Used for v3 APIs
- :param interface: Used to specify the endpoint type for keystone as public, admin, internal
+ :param interface: Used to specify the endpoint type for keystone as
+ public, admin, internal
:param proxy_settings: instance of os_credentials.ProxySettings class
- :param cacert: Default to be True for http, or the certification file is specified for https verification,
- or set to be False to disable server certificate verification without cert file
+ :param cacert: Default to be True for http, or the certification file
+ is specified for https verification, or set to be False
+ to disable server certificate verification without cert
+ file
"""
- self.username = username
- self.password = password
- self.auth_url = auth_url
- self.project_name = project_name
- self.identity_api_version = identity_api_version
- self.image_api_version = image_api_version
- self.network_api_version = network_api_version
- self.compute_api_version = compute_api_version
- self.user_domain_id = user_domain_id
- self.project_domain_id = project_domain_id
- self.interface = interface
- self.proxy_settings = proxy_settings
- self.cacert = cacert
-
- if self.proxy_settings and not isinstance(self.proxy_settings, ProxySettings):
- raise Exception('proxy_settings must be an instance of the class ProxySettings')
-
- if self.auth_url:
- auth_url_tokens = self.auth_url.split('/')
- last_token = auth_url_tokens[len(auth_url_tokens) - 1]
- if len(last_token) == 0:
- last_token = auth_url_tokens[len(auth_url_tokens) - 2]
-
- if not last_token.startswith('v'):
- raise Exception('auth_url last toke must start with \'v\'')
+ self.username = kwargs.get('username')
+ self.password = kwargs.get('password')
+ self.auth_url = kwargs.get('auth_url')
+ self.project_name = kwargs.get('project_name')
+ self.identity_api_version = kwargs.get('identity_api_version', 2)
+ self.image_api_version = kwargs.get('image_api_version', 2)
+ self.network_api_version = kwargs.get('network_api_version', 2)
+ self.compute_api_version = kwargs.get('compute_api_version', 2)
+ self.user_domain_id = kwargs.get('user_domain_id', 'default')
+ self.project_domain_id = kwargs.get('project_domain_id', 'default')
+ self.interface = kwargs.get('interface', 'admin')
+ self.cacert = kwargs.get('cacert', True)
+ if isinstance(kwargs.get('proxy_settings'), ProxySettings):
+ self.proxy_settings = kwargs.get('proxy_settings')
+ elif isinstance(kwargs.get('proxy_settings'), dict):
+ self.proxy_settings = ProxySettings(**kwargs.get('proxy_settings'))
+ else:
+ self.proxy_settings = None
+
+ if (not self.username or not self.password or not self.auth_url
+ or not self.project_name):
+ raise OSCredsError('username, password, auth_url, and project_name'
+ ' are required')
+
+ auth_url_tokens = self.auth_url.split('/')
+ last_token = auth_url_tokens[len(auth_url_tokens) - 1]
+ if len(last_token) == 0:
+ last_token = auth_url_tokens[len(auth_url_tokens) - 2]
+
+ if not last_token.startswith('v'):
+ raise OSCredsError('auth_url last toke must start with \'v\'')
+
+ @property
def __str__(self):
"""Converts object to a string"""
- return 'OSCreds - username=' + str(self.username) + \
- ', password=' + str(self.password) + \
- ', auth_url=' + str(self.auth_url) + \
- ', project_name=' + str(self.project_name) + \
- ', identity_api_version=' + str(self.identity_api_version) + \
- ', image_api_version=' + str(self.image_api_version) + \
- ', network_api_version=' + str(self.network_api_version) + \
- ', compute_api_version=' + str(self.compute_api_version) + \
- ', user_domain_id=' + str(self.user_domain_id) + \
- ', interface=' + str(self.interface) + \
- ', proxy_settings=' + str(self.proxy_settings) + \
- ', cacert=' + str(self.cacert)
+ return ('OSCreds - username=' + str(self.username) +
+ ', password=' + str(self.password) +
+ ', auth_url=' + str(self.auth_url) +
+ ', project_name=' + str(self.project_name) +
+ ', identity_api_version=' + str(self.identity_api_version) +
+ ', image_api_version=' + str(self.image_api_version) +
+ ', network_api_version=' + str(self.network_api_version) +
+ ', compute_api_version=' + str(self.compute_api_version) +
+ ', user_domain_id=' + str(self.user_domain_id) +
+ ', interface=' + str(self.interface) +
+ ', proxy_settings=' + str(self.proxy_settings) +
+ ', cacert=' + str(self.cacert))
class ProxySettings:
"""
- Represents the information required for sending traffic (HTTP & SSH) through a proxy
+ Represents the information required for sending traffic (HTTP & SSH)
+ through a proxy
"""
- def __init__(self, host, port, ssh_proxy_cmd=None):
+ def __init__(self, **kwargs):
"""
Constructor
:param host: the HTTP proxy host
:param port: the HTTP proxy port
:param ssh_proxy_cmd: the SSH proxy command string (optional)
"""
- # TODO - Add necessary fields here when adding support for secure proxies
+ self.host = kwargs.get('host')
+ self.port = kwargs.get('port')
+ self.ssh_proxy_cmd = kwargs.get('ssh_proxy_cmd')
- self.host = host
- self.port = port
- self.ssh_proxy_cmd = ssh_proxy_cmd
-
- if not self.host and not self.port:
- raise Exception('host & port are required')
+ if not self.host or not self.port:
+ raise ProxySettingsError('host & port are required')
def __str__(self):
"""Converts object to a string"""
return 'ProxySettings - host=' + str(self.host) + \
', port=' + str(self.port) + \
', ssh_proxy_cmd=' + str(self.ssh_proxy_cmd)
+
+
+class ProxySettingsError(Exception):
+ """
+ Exception to be thrown when an OSCred are invalid
+ """
+
+
+class OSCredsError(Exception):
+ """
+ Exception to be thrown when an OSCred are invalid
+ """
--- /dev/null
+# Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
+# and others. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import unittest
+
+from snaps.openstack.os_credentials import OSCredsError, OSCreds, \
+ ProxySettings, ProxySettingsError
+
+__author__ = 'spisarski'
+
+logger = logging.getLogger('os_credentials_test')
+
+
+class ProxySettingsUnitTests(unittest.TestCase):
+ """
+ Tests the construction of the ProxySettings class
+ """
+
+ def test_no_params(self):
+ with self.assertRaises(ProxySettingsError):
+ ProxySettings()
+
+ def test_empty_kwargs(self):
+ with self.assertRaises(ProxySettingsError):
+ ProxySettings(**dict())
+
+ def test_host_only(self):
+ with self.assertRaises(ProxySettingsError):
+ ProxySettings(host='foo')
+
+ def test_host_only_kwargs(self):
+ with self.assertRaises(ProxySettingsError):
+ ProxySettings(**{'host': 'foo'})
+
+ def test_port_only(self):
+ with self.assertRaises(ProxySettingsError):
+ ProxySettings(port=1234)
+
+ def test_port_only_kwargs(self):
+ with self.assertRaises(ProxySettingsError):
+ ProxySettings(**{'port': 1234})
+
+ def test_minimum(self):
+ proxy_settings = ProxySettings(host='foo', port=1234)
+ self.assertEqual('foo', proxy_settings.host)
+ self.assertEqual(1234, proxy_settings.port)
+ self.assertIsNone(proxy_settings.ssh_proxy_cmd)
+
+ def test_minimum_kwargs(self):
+ proxy_settings = ProxySettings(**{'host': 'foo', 'port': 1234})
+ self.assertEqual('foo', proxy_settings.host)
+ self.assertEqual(1234, proxy_settings.port)
+ self.assertIsNone(proxy_settings.ssh_proxy_cmd)
+
+ def test_all(self):
+ proxy_settings = ProxySettings(host='foo', port=1234,
+ ssh_proxy_cmd='proxy command')
+ self.assertEqual('foo', proxy_settings.host)
+ self.assertEqual(1234, proxy_settings.port)
+ self.assertEqual('proxy command', proxy_settings.ssh_proxy_cmd)
+
+ def test_all_kwargs(self):
+ proxy_settings = ProxySettings(
+ **{'host': 'foo', 'port': 1234, 'ssh_proxy_cmd': 'proxy command'})
+ self.assertEqual('foo', proxy_settings.host)
+ self.assertEqual(1234, proxy_settings.port)
+ self.assertEqual('proxy command', proxy_settings.ssh_proxy_cmd)
+
+
+class OSCredsUnitTests(unittest.TestCase):
+ """
+ Tests the construction of the OSCreds class
+ """
+
+ def test_no_params(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds()
+
+ def test_empty_kwargs(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(**dict())
+
+ def test_username_only(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(username='foo')
+
+ def test_username_only_kwargs(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(**{'username': 'foo'})
+
+ def test_password_only(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(password='foo')
+
+ def test_password_only_kwargs(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(**{'password': 'foo'})
+
+ def test_auth_url_only(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(auth_url='foo')
+
+ def test_auth_url_only_kwargs(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(**{'auth_url': 'foo'})
+
+ def test_project_name_only(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(project_name='foo')
+
+ def test_project_name_only_kwargs(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(**{'project_name': 'foo'})
+
+ def test_invalid_auth_url(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(username='foo', password='bar',
+ auth_url='http://foo.bar', project_name='hello')
+
+ def test_invalid_auth_url_kwargs(self):
+ with self.assertRaises(OSCredsError):
+ OSCreds(**{'username': 'foo', 'password': 'bar',
+ 'auth_url': 'http://foo.bar', 'project_name': 'hello'})
+
+ def test_minimal(self):
+ os_creds = OSCreds(
+ username='foo', password='bar', 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/v2', os_creds.auth_url)
+ self.assertEqual('hello', os_creds.project_name)
+ self.assertIsNone(os_creds.proxy_settings)
+
+ def test_minimal_kwargs(self):
+ os_creds = OSCreds(**{'username': 'foo', 'password': 'bar',
+ '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/v2', os_creds.auth_url)
+ self.assertEqual('hello', os_creds.project_name)
+ self.assertIsNone(os_creds.proxy_settings)
+
+ def test_proxy_settings_obj(self):
+ proxy_settings = ProxySettings(host='foo', port=1234)
+ os_creds = OSCreds(
+ username='foo', password='bar', auth_url='http://foo.bar:5000/v2',
+ 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/v2', os_creds.auth_url)
+ self.assertEqual('hello', os_creds.project_name)
+ 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_proxy_settings_obj_kwargs(self):
+ proxy_settings = ProxySettings(host='foo', port=1234)
+ os_creds = OSCreds(**{'username': 'foo', 'password': 'bar',
+ 'auth_url': 'http://foo.bar:5000/v2',
+ '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/v2', os_creds.auth_url)
+ self.assertEqual('hello', os_creds.project_name)
+ 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_proxy_settings_dict(self):
+ os_creds = OSCreds(
+ username='foo', password='bar', auth_url='http://foo.bar:5000/v2',
+ project_name='hello', proxy_settings={'host': 'foo', 'port': 1234})
+ self.assertEqual('foo', os_creds.username)
+ self.assertEqual('bar', os_creds.password)
+ self.assertEqual('http://foo.bar:5000/v2', os_creds.auth_url)
+ self.assertEqual('hello', os_creds.project_name)
+ 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_proxy_settings_dict_kwargs(self):
+ os_creds = OSCreds(**{'username': 'foo', 'password': 'bar',
+ 'auth_url': 'http://foo.bar:5000/v2',
+ 'project_name': 'hello',
+ 'proxy_settings': {'host': 'foo', 'port': 1234}})
+ self.assertEqual('foo', os_creds.username)
+ self.assertEqual('bar', os_creds.password)
+ self.assertEqual('http://foo.bar:5000/v2', os_creds.auth_url)
+ self.assertEqual('hello', os_creds.project_name)
+ 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)
proxy_settings = None
if proxy_settings_str:
tokens = re.split(':', proxy_settings_str)
- proxy_settings = ProxySettings(tokens[0], tokens[1], ssh_proxy_cmd)
+ proxy_settings = ProxySettings(host=tokens[0], port=tokens[1],
+ ssh_proxy_cmd=ssh_proxy_cmd)
if config.get('OS_CACERT'):
https_cacert = config.get('OS_CACERT')
proxy_str = config.get('http_proxy')
if proxy_str:
tokens = re.split(':', proxy_str)
- proxy_settings = ProxySettings(tokens[0], tokens[1],
- config.get('ssh_proxy_cmd'))
+ proxy_settings = ProxySettings(
+ host=tokens[0], port=tokens[1],
+ ssh_proxy_cmd=config.get('ssh_proxy_cmd'))
os_creds = OSCreds(username=config['username'],
password=config['password'],
image_api_version=image_api_version,
proxy_settings=proxy_settings)
- logger.info('OS Credentials = ' + str(os_creds))
+ logger.info('OS Credentials = %s', os_creds)
return os_creds
from snaps.openstack.os_credentials import OSCreds
with self.assertRaises(Exception):
- glance = glance_utils.glance_client(OSCreds('user', 'pass', 'url', 'project'))
+ glance = glance_utils.glance_client(OSCreds(
+ username='user', password='pass', auth_url='url',
+ project_name='project'))
glance_utils.get_image(glance, 'foo')
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
guid = uuid.uuid4()
self.image_name = self.__class__.__name__ + '-' + str(guid)
def test_create_image_minimal_url(self):
"""
- Tests the glance_utils.create_image() function with a URL unless the self.glance_test_meta has configured a
- file to be used.
+ Tests the glance_utils.create_image() function with a URL unless the
+ self.glance_test_meta has configured a file to be used.
"""
if 'disk_file' not in self.glance_test_meta:
- os_image_settings = openstack_tests.cirros_image_settings(name=self.image_name,
- image_metadata=self.glance_test_meta)
+ os_image_settings = openstack_tests.cirros_image_settings(
+ name=self.image_name, image_metadata=self.glance_test_meta)
- self.image = glance_utils.create_image(self.glance, os_image_settings)
+ self.image = glance_utils.create_image(self.glance,
+ os_image_settings)
self.assertIsNotNone(self.image)
self.assertEqual(self.image_name, self.image.name)
validation_utils.objects_equivalent(self.image, image)
else:
- logger.warn('Test not executed as the image metadata requires image files')
+ logger.warn('Test not executed as the image metadata requires '
+ 'image files')
def test_create_image_minimal_file(self):
"""
Tests the glance_utils.create_image() function with a file
"""
if 'disk_file' not in self.glance_test_meta:
- url_image_settings = openstack_tests.cirros_image_settings(name='foo', image_metadata=self.glance_test_meta)
- image_file_name = file_utils.download(url_image_settings.url, self.tmp_dir).name
+ url_image_settings = openstack_tests.cirros_image_settings(
+ name='foo', image_metadata=self.glance_test_meta)
+ image_file_name = file_utils.download(
+ url_image_settings.url, self.tmp_dir).name
else:
image_file_name = self.glance_test_meta['disk_file']
- file_image_settings = openstack_tests.file_image_test_settings(name=self.image_name, file_path=image_file_name)
+ file_image_settings = openstack_tests.file_image_test_settings(
+ name=self.image_name, file_path=image_file_name)
- self.image = glance_utils.create_image(self.glance, file_image_settings)
+ self.image = glance_utils.create_image(self.glance,
+ file_image_settings)
self.assertIsNotNone(self.image)
self.assertEqual(self.image_name, self.image.name)
from snaps.openstack.os_credentials import OSCreds
with self.assertRaises(Exception):
- keystone = keystone_utils.keystone_client(OSCreds('user', 'pass', 'url', 'project'))
+ keystone = keystone_utils.keystone_client(OSCreds(
+ username='user', password='pass', auth_url='url',
+ project_name='project'))
keystone.users.list()
def setUp(self):
"""
- Instantiates the CreateImage object that is responsible for downloading and creating an OS image file
- within OpenStack
+ Instantiates the CreateImage object that is responsible for downloading
+ and creating an OS image file within OpenStack
"""
guid = uuid.uuid4()
self.username = self.__class__.__name__ + '-' + str(guid)
Tests the keyston_utils.create_project() funtion
"""
project_settings = ProjectSettings(name=self.project_name)
- self.project = keystone_utils.create_project(self.keystone, project_settings)
+ self.project = keystone_utils.create_project(self.keystone,
+ project_settings)
self.assertEqual(self.project_name, self.project.name)
- project = keystone_utils.get_project(keystone=self.keystone, project_name=project_settings.name)
+ project = keystone_utils.get_project(
+ keystone=self.keystone, project_name=project_settings.name)
self.assertIsNotNone(project)
self.assertEqual(self.project_name, self.project.name)
def test_get_endpoint_success(self):
"""
- Tests to ensure that proper credentials and proper service type can succeed.
+ Tests to ensure that proper credentials and proper service type can
+ succeed.
"""
endpoint = keystone_utils.get_endpoint(self.os_creds,
service_type="identity")
def test_get_endpoint_fail_without_proper_service(self):
"""
- Tests to ensure that proper credentials and improper service type cannot succeed.
+ Tests to ensure that proper credentials and improper service type
+ cannot succeed.
"""
with self.assertRaises(Exception):
keystone_utils.get_endpoint(self.os_creds, service_type="glance")
def test_get_endpoint_fail_without_proper_credentials(self):
"""
- Tests to ensure that improper credentials and proper service type cannot succeed.
+ 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('user', 'pass', 'url', 'project'),
+ OSCreds(username='user', password='pass', auth_url='url',
+ project_name='project'),
service_type="image")
from snaps.domain.test.stack_tests import StackDomainObjectTests
from snaps.domain.test.vm_inst_tests import (VmInstDomainObjectTests,
FloatingIpDomainObjectTests)
+from snaps.openstack.tests.conf.os_credentials_tests import (
+ ProxySettingsUnitTests, OSCredsUnitTests)
from snaps.openstack.tests.create_flavor_tests import CreateFlavorTests
from snaps.openstack.tests.create_image_tests import (
CreateImageSuccessTests, CreateImageNegativeTests, ImageSettingsUnitTests,
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(FileUtilsTests))
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
SecurityGroupRuleSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ ProxySettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ OSCredsUnitTests))
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
SecurityGroupSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(ImageSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(ImageDomainObjectTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(KeypairSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(UserSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(ProjectSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(NetworkSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(SubnetSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(PortSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ ImageSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ ImageDomainObjectTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ KeypairSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ UserSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ ProjectSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ NetworkSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ SubnetSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ PortSettingsUnitTests))
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
FloatingIpSettingsUnitTests))
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
VmInstanceSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(StackDomainObjectTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(StackSettingsUnitTests))
- suite.addTest(
- unittest.TestLoader().loadTestsFromTestCase(VmInstDomainObjectTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ StackDomainObjectTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ StackSettingsUnitTests))
+ suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
+ VmInstDomainObjectTests))
suite.addTest(unittest.TestLoader().loadTestsFromTestCase(
FloatingIpDomainObjectTests))
Code Review / snaps.git / commitdiff