Merge "Tests to verify Nova VM Rescue operations"
diff --git a/cli/__init__.py b/cli/__init__.py
index cea0b62..2548f24 100644
--- a/cli/__init__.py
+++ b/cli/__init__.py
@@ -16,8 +16,13 @@
# under the License.
import logging
+import shlex
+import subprocess
-from tempest.openstack.common import cfg
+from oslo.config import cfg
+
+import tempest.test
+
LOG = logging.getLogger(__name__)
@@ -34,3 +39,45 @@
cli_group = cfg.OptGroup(name='cli', title="cli Configuration Options")
CONF.register_group(cli_group)
CONF.register_opts(cli_opts, group=cli_group)
+
+
+class ClientTestBase(tempest.test.BaseTestCase):
+ @classmethod
+ def setUpClass(cls):
+ if not CONF.cli.enabled:
+ msg = "cli testing disabled"
+ raise cls.skipException(msg)
+ cls.identity = cls.config.identity
+ super(ClientTestBase, cls).setUpClass()
+
+ def __init__(self, *args, **kwargs):
+ super(ClientTestBase, self).__init__(*args, **kwargs)
+
+ def nova(self, action, flags='', params='', admin=True, fail_ok=False):
+ """Executes nova command for the given action."""
+ return self.cmd_with_auth(
+ 'nova', action, flags, params, admin, fail_ok)
+
+ def cmd_with_auth(self, cmd, action, flags='', params='',
+ admin=True, fail_ok=False):
+ """Executes given command with auth attributes appended."""
+ #TODO(jogo) make admin=False work
+ creds = ('--os-username %s --os-tenant-name %s --os-password %s '
+ '--os-auth-url %s ' % (self.identity.admin_username,
+ self.identity.admin_tenant_name, self.identity.admin_password,
+ self.identity.uri))
+ flags = creds + ' ' + flags
+ return self.cmd(cmd, action, flags, params, fail_ok)
+
+ def cmd(self, cmd, action, flags='', params='', fail_ok=False):
+ """Executes specified command for the given action."""
+ cmd = ' '.join([CONF.cli.cli_dir + cmd,
+ flags, action, params])
+ LOG.info("running: '%s'" % cmd)
+ cmd = shlex.split(cmd)
+ try:
+ result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+ except subprocess.CalledProcessError, e:
+ LOG.error("command output:\n%s" % e.output)
+ raise
+ return result
diff --git a/cli/simple_read_only/test_compute.py b/cli/simple_read_only/test_compute.py
index 073fde1..bcdd2c5 100644
--- a/cli/simple_read_only/test_compute.py
+++ b/cli/simple_read_only/test_compute.py
@@ -16,15 +16,13 @@
# under the License.
import logging
-import shlex
import subprocess
+from oslo.config import cfg
import testtools
import cli
-
from tempest import config
-from tempest.openstack.common import cfg
CONF = cfg.CONF
@@ -33,7 +31,7 @@
LOG = logging.getLogger(__name__)
-class SimpleReadOnlyNovaCLientTest(testtools.TestCase):
+class SimpleReadOnlyNovaClientTest(cli.ClientTestBase):
"""
This is a first pass at a simple read only python-novaclient test. This
@@ -47,33 +45,6 @@
"""
- @classmethod
- def setUpClass(cls):
- if not CONF.cli.enabled:
- msg = "cli testing disabled"
- raise cls.skipException(msg)
- cls.identity = config.TempestConfig().identity
- super(SimpleReadOnlyNovaCLientTest, cls).setUpClass()
-
- #NOTE(jogo): This should eventually be moved into a base class
- def nova(self, action, flags='', params='', admin=True, fail_ok=False):
- """Executes nova command for the given action."""
- #TODO(jogo) make admin=False work
- creds = ('--os-username %s --os-tenant-name %s --os-password %s '
- '--os-auth-url %s ' % (self.identity.admin_username,
- self.identity.admin_tenant_name, self.identity.admin_password,
- self.identity.uri))
- flags = creds + ' ' + flags
- cmd = ' '.join([CONF.cli.cli_dir + 'nova', flags, action, params])
- LOG.info("running: '%s'" % cmd)
- cmd = shlex.split(cmd)
- try:
- result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
- except subprocess.CalledProcessError, e:
- LOG.error("command output:\n%s" % e.output)
- raise
- return result
-
def test_admin_fake_action(self):
self.assertRaises(subprocess.CalledProcessError,
self.nova,
diff --git a/etc/tempest.conf.sample b/etc/tempest.conf.sample
index 9dca609..02bfdcb 100644
--- a/etc/tempest.conf.sample
+++ b/etc/tempest.conf.sample
@@ -88,6 +88,9 @@
# Number of seconds to wait to authenticate to an instance
ssh_timeout = 300
+# Number of seconds to wait for output from ssh channel
+ssh_channel_timeout = 60
+
# The type of endpoint for a Compute API service. Unless you have a
# custom Keystone service catalog implementation, you probably want to leave
# this value as "compute"
@@ -190,6 +193,9 @@
# for each tenant to have their own router.
public_router_id = {$PUBLIC_ROUTER_ID}
+# Whether or not quantum is expected to be available
+quantum_available = false
+
[volume]
# This section contains the configuration options used when executing tests
# against the OpenStack Block Storage API service
@@ -238,20 +244,20 @@
#Image materials for S3 upload
# ALL content of the specified directory will be uploaded to S3
-s3_materials_path = /opt/stack/devstack/files/images/s3-materials/cirros-0.3.0
+s3_materials_path = /opt/stack/devstack/files/images/s3-materials/cirros-0.3.1
# The manifest.xml files, must be in the s3_materials_path directory
# Subdirectories not allowed!
# The filenames will be used as a Keys in the S3 Buckets
#ARI Ramdisk manifest. Must be in the above s3_materials_path
-ari_manifest = cirros-0.3.0-x86_64-initrd.manifest.xml
+ari_manifest = cirros-0.3.1-x86_64-initrd.manifest.xml
#AMI Machine Image manifest. Must be in the above s3_materials_path
-ami_manifest = cirros-0.3.0-x86_64-blank.img.manifest.xml
+ami_manifest = cirros-0.3.1-x86_64-blank.img.manifest.xml
#AKI Kernel Image manifest, Must be in the above s3_materials_path
-aki_manifest = cirros-0.3.0-x86_64-vmlinuz.manifest.xml
+aki_manifest = cirros-0.3.1-x86_64-vmlinuz.manifest.xml
#Instance type
instance_type = m1.tiny
diff --git a/openstack-common.conf b/openstack-common.conf
index 0c9e43e..501328c 100644
--- a/openstack-common.conf
+++ b/openstack-common.conf
@@ -1,7 +1,7 @@
[DEFAULT]
# The list of modules to copy from openstack-common
-modules=setup,cfg,iniparser,install_venv_common
+modules=setup,install_venv_common
# The base module to hold the copy of openstack.common
base=tempest
diff --git a/tempest/clients.py b/tempest/clients.py
index ef07d9c..b3b5906 100644
--- a/tempest/clients.py
+++ b/tempest/clients.py
@@ -52,7 +52,8 @@
from tempest.services.identity.json.identity_client import TokenClientJSON
from tempest.services.identity.xml.identity_client import IdentityClientXML
from tempest.services.identity.xml.identity_client import TokenClientXML
-from tempest.services.image.json.image_client import ImageClientJSON
+from tempest.services.image.v1.json.image_client import ImageClientJSON
+from tempest.services.image.v2.json.image_client import ImageClientV2JSON
from tempest.services.network.json.network_client import NetworkClient
from tempest.services.object_storage.account_client import AccountClient
from tempest.services.object_storage.account_client import \
@@ -69,6 +70,10 @@
VolumeTypesClientXML
from tempest.services.volume.xml.snapshots_client import SnapshotsClientXML
from tempest.services.volume.xml.volumes_client import VolumesClientXML
+from tempest.services.compute.json.interfaces_client import \
+ InterfacesClientJSON
+from tempest.services.compute.xml.interfaces_client import \
+ InterfacesClientXML
LOG = logging.getLogger(__name__)
@@ -147,6 +152,11 @@
"xml": SecurityGroupsClientXML,
}
+INTERFACES_CLIENT = {
+ "json": InterfacesClientJSON,
+ "xml": InterfacesClientXML,
+}
+
class Manager(object):
@@ -208,6 +218,7 @@
self.token_client = TOKEN_CLIENT[interface](self.config)
self.security_groups_client = \
SECURITY_GROUPS_CLIENT[interface](*client_args)
+ self.interfaces_client = INTERFACES_CLIENT[interface](*client_args)
except KeyError:
msg = "Unsupported interface type `%s'" % interface
raise exceptions.InvalidConfiguration(msg)
@@ -215,6 +226,7 @@
self.hosts_client = HostsClientJSON(*client_args)
self.account_client = AccountClient(*client_args)
self.image_client = ImageClientJSON(*client_args)
+ self.image_client_v2 = ImageClientV2JSON(*client_args)
self.container_client = ContainerClient(*client_args)
self.object_client = ObjectClient(*client_args)
self.ec2api_client = botoclients.APIClientEC2(*client_args)
diff --git a/tempest/common/glance_http.py b/tempest/common/glance_http.py
index 36a9abd..0902239 100644
--- a/tempest/common/glance_http.py
+++ b/tempest/common/glance_http.py
@@ -18,6 +18,7 @@
import copy
import hashlib
import httplib
+import json
import logging
import posixpath
import re
@@ -26,10 +27,6 @@
import struct
import urlparse
-try:
- import json
-except ImportError:
- import simplejson as json
# Python 2.5 compat fix
if not hasattr(urlparse, 'parse_qsl'):
@@ -129,11 +126,11 @@
resp = conn.getresponse()
except socket.gaierror as e:
message = "Error finding address for %(url)s: %(e)s" % locals()
- raise exc.EndpointNotFound
+ raise exc.EndpointNotFound(message)
except (socket.error, socket.timeout) as e:
endpoint = self.endpoint
message = "Error communicating with %(endpoint)s %(e)s" % locals()
- raise exc.TimeoutException
+ raise exc.TimeoutException(message)
body_iter = ResponseBodyIterator(resp)
diff --git a/tempest/common/rest_client.py b/tempest/common/rest_client.py
index 170a137..5ce3be6 100644
--- a/tempest/common/rest_client.py
+++ b/tempest/common/rest_client.py
@@ -177,8 +177,8 @@
def post(self, url, body, headers):
return self.request('POST', url, headers, body)
- def get(self, url, headers=None, wait=None):
- return self.request('GET', url, headers, wait=wait)
+ def get(self, url, headers=None):
+ return self.request('GET', url, headers)
def delete(self, url, headers=None):
return self.request('DELETE', url, headers)
@@ -257,7 +257,7 @@
self.LOG.warning("status >= 400 response with empty body")
def request(self, method, url,
- headers=None, body=None, depth=0, wait=None):
+ headers=None, body=None, depth=0):
"""A simple HTTP request interface."""
if (self.token is None) or (self.base_url is None):
@@ -276,13 +276,12 @@
self._log_response(resp, resp_body)
self.response_checker(method, url, headers, body, resp, resp_body)
- self._error_checker(method, url, headers, body, resp, resp_body, depth,
- wait)
+ self._error_checker(method, url, headers, body, resp, resp_body, depth)
return resp, resp_body
def _error_checker(self, method, url,
- headers, body, resp, resp_body, depth=0, wait=None):
+ headers, body, resp, resp_body, depth=0):
# NOTE(mtreinish): Check for httplib response from glance_http. The
# object can't be used here because importing httplib breaks httplib2.
@@ -336,7 +335,12 @@
resp_body = self._parse_resp(resp_body)
#Checking whether Absolute/Rate limit
return self.check_over_limit(resp_body, method, url, headers, body,
- depth, wait)
+ depth)
+
+ if resp.status == 422:
+ if parse_resp:
+ resp_body = self._parse_resp(resp_body)
+ raise exceptions.UnprocessableEntity(resp_body)
if resp.status in (500, 501):
message = resp_body
@@ -362,11 +366,11 @@
raise exceptions.RestClientException(str(resp.status))
def check_over_limit(self, resp_body, method, url,
- headers, body, depth, wait):
+ headers, body, depth):
self.is_absolute_limit(resp_body['overLimit'])
return self.is_rate_limit_retry_max_recursion_depth(
resp_body['overLimit'], method, url, headers,
- body, depth, wait)
+ body, depth)
def is_absolute_limit(self, resp_body):
if 'exceeded' in resp_body['message']:
@@ -375,15 +379,14 @@
return
def is_rate_limit_retry_max_recursion_depth(self, resp_body, method,
- url, headers, body, depth,
- wait):
+ url, headers, body, depth):
if 'retryAfter' in resp_body:
if depth < MAX_RECURSION_DEPTH:
delay = resp_body['retryAfter']
time.sleep(int(delay))
return self.request(method, url, headers=headers,
body=body,
- depth=depth + 1, wait=wait)
+ depth=depth + 1)
else:
raise exceptions.RateLimitExceeded(
message=resp_body['overLimitFault']['message'],
@@ -417,8 +420,8 @@
return xml_to_json(etree.fromstring(body))
def check_over_limit(self, resp_body, method, url,
- headers, body, depth, wait):
+ headers, body, depth):
self.is_absolute_limit(resp_body)
return self.is_rate_limit_retry_max_recursion_depth(
resp_body, method, url, headers,
- body, depth, wait)
+ body, depth)
diff --git a/tempest/common/ssh.py b/tempest/common/ssh.py
index 151060f..be6fe27 100644
--- a/tempest/common/ssh.py
+++ b/tempest/common/ssh.py
@@ -106,6 +106,7 @@
ssh = self._get_ssh_connection()
transport = ssh.get_transport()
channel = transport.open_session()
+ channel.fileno() # Register event pipe
channel.exec_command(cmd)
channel.shutdown_write()
out_data = []
diff --git a/tempest/common/utils/linux/remote_client.py b/tempest/common/utils/linux/remote_client.py
index b501df4..fd5d3d0 100644
--- a/tempest/common/utils/linux/remote_client.py
+++ b/tempest/common/utils/linux/remote_client.py
@@ -15,6 +15,7 @@
ssh_timeout = TempestConfig().compute.ssh_timeout
network = TempestConfig().compute.network_for_ssh
ip_version = TempestConfig().compute.ip_version_for_ssh
+ ssh_channel_timeout = TempestConfig().compute.ssh_channel_timeout
if isinstance(server, basestring):
ip_address = server
else:
@@ -27,7 +28,8 @@
raise ServerUnreachable()
self.ssh_client = Client(ip_address, username, password, ssh_timeout,
- pkey=pkey)
+ pkey=pkey,
+ channel_timeout=ssh_channel_timeout)
if not self.ssh_client.test_connection_auth():
raise SSHTimeout()
diff --git a/tempest/config.py b/tempest/config.py
index c0e25c7..3a4a8c9 100644
--- a/tempest/config.py
+++ b/tempest/config.py
@@ -19,8 +19,9 @@
import os
import sys
+from oslo.config import cfg
+
from tempest.common.utils.misc import singleton
-from tempest.openstack.common import cfg
LOG = logging.getLogger(__name__)
@@ -149,8 +150,12 @@
help="User name used to authenticate to an instance."),
cfg.IntOpt('ssh_timeout',
default=300,
- help="Timeout in seconds to wait for authentcation to "
+ help="Timeout in seconds to wait for authentication to "
"succeed."),
+ cfg.IntOpt('ssh_channel_timeout',
+ default=60,
+ help="Timeout in seconds to wait for output from ssh "
+ "channel."),
cfg.StrOpt('network_for_ssh',
default='public',
help="Network used for SSH connections."),
@@ -276,6 +281,9 @@
default="",
help="Id of the public router that provides external "
"connectivity"),
+ cfg.BoolOpt('quantum_available',
+ default=False,
+ help="Whether or not quantum is expected to be available"),
]
diff --git a/tempest/exceptions.py b/tempest/exceptions.py
index 577aa13..235a2e7 100644
--- a/tempest/exceptions.py
+++ b/tempest/exceptions.py
@@ -94,6 +94,10 @@
message = "Bad request"
+class UnprocessableEntity(RestClientException):
+ message = "Unprocessable entity"
+
+
class AuthenticationFailure(RestClientException):
message = ("Authentication with user %(user)s and password "
"%(password)s failed")
diff --git a/tempest/openstack/common/cfg.py b/tempest/openstack/common/cfg.py
deleted file mode 100644
index cae4ecc..0000000
--- a/tempest/openstack/common/cfg.py
+++ /dev/null
@@ -1,1749 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2012 Red Hat, Inc.
-#
-# 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.
-
-r"""
-Configuration options which may be set on the command line or in config files.
-
-The schema for each option is defined using the Opt sub-classes, e.g.:
-
-::
-
- common_opts = [
- cfg.StrOpt('bind_host',
- default='0.0.0.0',
- help='IP address to listen on'),
- cfg.IntOpt('bind_port',
- default=9292,
- help='Port number to listen on')
- ]
-
-Options can be strings, integers, floats, booleans, lists or 'multi strings'::
-
- enabled_apis_opt = cfg.ListOpt('enabled_apis',
- default=['ec2', 'osapi_compute'],
- help='List of APIs to enable by default')
-
- DEFAULT_EXTENSIONS = [
- 'nova.api.openstack.compute.contrib.standard_extensions'
- ]
- osapi_compute_extension_opt = cfg.MultiStrOpt('osapi_compute_extension',
- default=DEFAULT_EXTENSIONS)
-
-Option schemas are registered with the config manager at runtime, but before
-the option is referenced::
-
- class ExtensionManager(object):
-
- enabled_apis_opt = cfg.ListOpt(...)
-
- def __init__(self, conf):
- self.conf = conf
- self.conf.register_opt(enabled_apis_opt)
- ...
-
- def _load_extensions(self):
- for ext_factory in self.conf.osapi_compute_extension:
- ....
-
-A common usage pattern is for each option schema to be defined in the module or
-class which uses the option::
-
- opts = ...
-
- def add_common_opts(conf):
- conf.register_opts(opts)
-
- def get_bind_host(conf):
- return conf.bind_host
-
- def get_bind_port(conf):
- return conf.bind_port
-
-An option may optionally be made available via the command line. Such options
-must registered with the config manager before the command line is parsed (for
-the purposes of --help and CLI arg validation)::
-
- cli_opts = [
- cfg.BoolOpt('verbose',
- short='v',
- default=False,
- help='Print more verbose output'),
- cfg.BoolOpt('debug',
- short='d',
- default=False,
- help='Print debugging output'),
- ]
-
- def add_common_opts(conf):
- conf.register_cli_opts(cli_opts)
-
-The config manager has two CLI options defined by default, --config-file
-and --config-dir::
-
- class ConfigOpts(object):
-
- def __call__(self, ...):
-
- opts = [
- MultiStrOpt('config-file',
- ...),
- StrOpt('config-dir',
- ...),
- ]
-
- self.register_cli_opts(opts)
-
-Option values are parsed from any supplied config files using
-openstack.common.iniparser. If none are specified, a default set is used
-e.g. glance-api.conf and glance-common.conf::
-
- glance-api.conf:
- [DEFAULT]
- bind_port = 9292
-
- glance-common.conf:
- [DEFAULT]
- bind_host = 0.0.0.0
-
-Option values in config files override those on the command line. Config files
-are parsed in order, with values in later files overriding those in earlier
-files.
-
-The parsing of CLI args and config files is initiated by invoking the config
-manager e.g.::
-
- conf = ConfigOpts()
- conf.register_opt(BoolOpt('verbose', ...))
- conf(sys.argv[1:])
- if conf.verbose:
- ...
-
-Options can be registered as belonging to a group::
-
- rabbit_group = cfg.OptGroup(name='rabbit',
- title='RabbitMQ options')
-
- rabbit_host_opt = cfg.StrOpt('host',
- default='localhost',
- help='IP/hostname to listen on'),
- rabbit_port_opt = cfg.IntOpt('port',
- default=5672,
- help='Port number to listen on')
-
- def register_rabbit_opts(conf):
- conf.register_group(rabbit_group)
- # options can be registered under a group in either of these ways:
- conf.register_opt(rabbit_host_opt, group=rabbit_group)
- conf.register_opt(rabbit_port_opt, group='rabbit')
-
-If it no group attributes are required other than the group name, the group
-need not be explicitly registered e.g.
-
- def register_rabbit_opts(conf):
- # The group will automatically be created, equivalent calling::
- # conf.register_group(OptGroup(name='rabbit'))
- conf.register_opt(rabbit_port_opt, group='rabbit')
-
-If no group is specified, options belong to the 'DEFAULT' section of config
-files::
-
- glance-api.conf:
- [DEFAULT]
- bind_port = 9292
- ...
-
- [rabbit]
- host = localhost
- port = 5672
- use_ssl = False
- userid = guest
- password = guest
- virtual_host = /
-
-Command-line options in a group are automatically prefixed with the
-group name::
-
- --rabbit-host localhost --rabbit-port 9999
-
-Option values in the default group are referenced as attributes/properties on
-the config manager; groups are also attributes on the config manager, with
-attributes for each of the options associated with the group::
-
- server.start(app, conf.bind_port, conf.bind_host, conf)
-
- self.connection = kombu.connection.BrokerConnection(
- hostname=conf.rabbit.host,
- port=conf.rabbit.port,
- ...)
-
-Option values may reference other values using PEP 292 string substitution::
-
- opts = [
- cfg.StrOpt('state_path',
- default=os.path.join(os.path.dirname(__file__), '../'),
- help='Top-level directory for maintaining nova state'),
- cfg.StrOpt('sqlite_db',
- default='nova.sqlite',
- help='file name for sqlite'),
- cfg.StrOpt('sql_connection',
- default='sqlite:///$state_path/$sqlite_db',
- help='connection string for sql database'),
- ]
-
-Note that interpolation can be avoided by using '$$'.
-
-Options may be declared as required so that an error is raised if the user
-does not supply a value for the option.
-
-Options may be declared as secret so that their values are not leaked into
-log files::
-
- opts = [
- cfg.StrOpt('s3_store_access_key', secret=True),
- cfg.StrOpt('s3_store_secret_key', secret=True),
- ...
- ]
-
-This module also contains a global instance of the ConfigOpts class
-in order to support a common usage pattern in OpenStack::
-
- from tempest.openstack.common import cfg
-
- opts = [
- cfg.StrOpt('bind_host', default='0.0.0.0'),
- cfg.IntOpt('bind_port', default=9292),
- ]
-
- CONF = cfg.CONF
- CONF.register_opts(opts)
-
- def start(server, app):
- server.start(app, CONF.bind_port, CONF.bind_host)
-
-Positional command line arguments are supported via a 'positional' Opt
-constructor argument::
-
- >>> conf = ConfigOpts()
- >>> conf.register_cli_opt(MultiStrOpt('bar', positional=True))
- True
- >>> conf(['a', 'b'])
- >>> conf.bar
- ['a', 'b']
-
-It is also possible to use argparse "sub-parsers" to parse additional
-command line arguments using the SubCommandOpt class:
-
- >>> def add_parsers(subparsers):
- ... list_action = subparsers.add_parser('list')
- ... list_action.add_argument('id')
- ...
- >>> conf = ConfigOpts()
- >>> conf.register_cli_opt(SubCommandOpt('action', handler=add_parsers))
- True
- >>> conf(args=['list', '10'])
- >>> conf.action.name, conf.action.id
- ('list', '10')
-
-"""
-
-import argparse
-import collections
-import copy
-import functools
-import glob
-import os
-import string
-import sys
-
-from tempest.openstack.common import iniparser
-
-
-class Error(Exception):
- """Base class for cfg exceptions."""
-
- def __init__(self, msg=None):
- self.msg = msg
-
- def __str__(self):
- return self.msg
-
-
-class ArgsAlreadyParsedError(Error):
- """Raised if a CLI opt is registered after parsing."""
-
- def __str__(self):
- ret = "arguments already parsed"
- if self.msg:
- ret += ": " + self.msg
- return ret
-
-
-class NoSuchOptError(Error, AttributeError):
- """Raised if an opt which doesn't exist is referenced."""
-
- def __init__(self, opt_name, group=None):
- self.opt_name = opt_name
- self.group = group
-
- def __str__(self):
- if self.group is None:
- return "no such option: %s" % self.opt_name
- else:
- return "no such option in group %s: %s" % (self.group.name,
- self.opt_name)
-
-
-class NoSuchGroupError(Error):
- """Raised if a group which doesn't exist is referenced."""
-
- def __init__(self, group_name):
- self.group_name = group_name
-
- def __str__(self):
- return "no such group: %s" % self.group_name
-
-
-class DuplicateOptError(Error):
- """Raised if multiple opts with the same name are registered."""
-
- def __init__(self, opt_name):
- self.opt_name = opt_name
-
- def __str__(self):
- return "duplicate option: %s" % self.opt_name
-
-
-class RequiredOptError(Error):
- """Raised if an option is required but no value is supplied by the user."""
-
- def __init__(self, opt_name, group=None):
- self.opt_name = opt_name
- self.group = group
-
- def __str__(self):
- if self.group is None:
- return "value required for option: %s" % self.opt_name
- else:
- return "value required for option: %s.%s" % (self.group.name,
- self.opt_name)
-
-
-class TemplateSubstitutionError(Error):
- """Raised if an error occurs substituting a variable in an opt value."""
-
- def __str__(self):
- return "template substitution error: %s" % self.msg
-
-
-class ConfigFilesNotFoundError(Error):
- """Raised if one or more config files are not found."""
-
- def __init__(self, config_files):
- self.config_files = config_files
-
- def __str__(self):
- return ('Failed to read some config files: %s' %
- string.join(self.config_files, ','))
-
-
-class ConfigFileParseError(Error):
- """Raised if there is an error parsing a config file."""
-
- def __init__(self, config_file, msg):
- self.config_file = config_file
- self.msg = msg
-
- def __str__(self):
- return 'Failed to parse %s: %s' % (self.config_file, self.msg)
-
-
-class ConfigFileValueError(Error):
- """Raised if a config file value does not match its opt type."""
- pass
-
-
-def _fixpath(p):
- """Apply tilde expansion and absolutization to a path."""
- return os.path.abspath(os.path.expanduser(p))
-
-
-def _get_config_dirs(project=None):
- """Return a list of directors where config files may be located.
-
- :param project: an optional project name
-
- If a project is specified, following directories are returned::
-
- ~/.${project}/
- ~/
- /etc/${project}/
- /etc/
-
- Otherwise, these directories::
-
- ~/
- /etc/
- """
- cfg_dirs = [
- _fixpath(os.path.join('~', '.' + project)) if project else None,
- _fixpath('~'),
- os.path.join('/etc', project) if project else None,
- '/etc'
- ]
-
- return filter(bool, cfg_dirs)
-
-
-def _search_dirs(dirs, basename, extension=""):
- """Search a list of directories for a given filename.
-
- Iterator over the supplied directories, returning the first file
- found with the supplied name and extension.
-
- :param dirs: a list of directories
- :param basename: the filename, e.g. 'glance-api'
- :param extension: the file extension, e.g. '.conf'
- :returns: the path to a matching file, or None
- """
- for d in dirs:
- path = os.path.join(d, '%s%s' % (basename, extension))
- if os.path.exists(path):
- return path
-
-
-def find_config_files(project=None, prog=None, extension='.conf'):
- """Return a list of default configuration files.
-
- :param project: an optional project name
- :param prog: the program name, defaulting to the basename of sys.argv[0]
- :param extension: the type of the config file
-
- We default to two config files: [${project}.conf, ${prog}.conf]
-
- And we look for those config files in the following directories::
-
- ~/.${project}/
- ~/
- /etc/${project}/
- /etc/
-
- We return an absolute path for (at most) one of each the default config
- files, for the topmost directory it exists in.
-
- For example, if project=foo, prog=bar and /etc/foo/foo.conf, /etc/bar.conf
- and ~/.foo/bar.conf all exist, then we return ['/etc/foo/foo.conf',
- '~/.foo/bar.conf']
-
- If no project name is supplied, we only look for ${prog.conf}.
- """
- if prog is None:
- prog = os.path.basename(sys.argv[0])
-
- cfg_dirs = _get_config_dirs(project)
-
- config_files = []
- if project:
- config_files.append(_search_dirs(cfg_dirs, project, extension))
- config_files.append(_search_dirs(cfg_dirs, prog, extension))
-
- return filter(bool, config_files)
-
-
-def _is_opt_registered(opts, opt):
- """Check whether an opt with the same name is already registered.
-
- The same opt may be registered multiple times, with only the first
- registration having any effect. However, it is an error to attempt
- to register a different opt with the same name.
-
- :param opts: the set of opts already registered
- :param opt: the opt to be registered
- :returns: True if the opt was previously registered, False otherwise
- :raises: DuplicateOptError if a naming conflict is detected
- """
- if opt.dest in opts:
- if opts[opt.dest]['opt'] != opt:
- raise DuplicateOptError(opt.name)
- return True
- else:
- return False
-
-
-def set_defaults(opts, **kwargs):
- for opt in opts:
- if opt.dest in kwargs:
- opt.default = kwargs[opt.dest]
- break
-
-
-class Opt(object):
-
- """Base class for all configuration options.
-
- An Opt object has no public methods, but has a number of public string
- properties:
-
- name:
- the name of the option, which may include hyphens
- dest:
- the (hyphen-less) ConfigOpts property which contains the option value
- short:
- a single character CLI option name
- default:
- the default value of the option
- positional:
- True if the option is a positional CLI argument
- metavar:
- the name shown as the argument to a CLI option in --help output
- help:
- an string explaining how the options value is used
- """
- multi = False
-
- def __init__(self, name, dest=None, short=None, default=None,
- positional=False, metavar=None, help=None,
- secret=False, required=False, deprecated_name=None):
- """Construct an Opt object.
-
- The only required parameter is the option's name. However, it is
- common to also supply a default and help string for all options.
-
- :param name: the option's name
- :param dest: the name of the corresponding ConfigOpts property
- :param short: a single character CLI option name
- :param default: the default value of the option
- :param positional: True if the option is a positional CLI argument
- :param metavar: the option argument to show in --help
- :param help: an explanation of how the option is used
- :param secret: true iff the value should be obfuscated in log output
- :param required: true iff a value must be supplied for this option
- :param deprecated_name: deprecated name option. Acts like an alias
- """
- self.name = name
- if dest is None:
- self.dest = self.name.replace('-', '_')
- else:
- self.dest = dest
- self.short = short
- self.default = default
- self.positional = positional
- self.metavar = metavar
- self.help = help
- self.secret = secret
- self.required = required
- if deprecated_name is not None:
- self.deprecated_name = deprecated_name.replace('-', '_')
- else:
- self.deprecated_name = None
-
- def __ne__(self, another):
- return vars(self) != vars(another)
-
- def _get_from_config_parser(self, cparser, section):
- """Retrieves the option value from a MultiConfigParser object.
-
- This is the method ConfigOpts uses to look up the option value from
- config files. Most opt types override this method in order to perform
- type appropriate conversion of the returned value.
-
- :param cparser: a ConfigParser object
- :param section: a section name
- """
- return self._cparser_get_with_deprecated(cparser, section)
-
- def _cparser_get_with_deprecated(self, cparser, section):
- """If cannot find option as dest try deprecated_name alias."""
- if self.deprecated_name is not None:
- return cparser.get(section, [self.dest, self.deprecated_name])
- return cparser.get(section, [self.dest])
-
- def _add_to_cli(self, parser, group=None):
- """Makes the option available in the command line interface.
-
- This is the method ConfigOpts uses to add the opt to the CLI interface
- as appropriate for the opt type. Some opt types may extend this method,
- others may just extend the helper methods it uses.
-
- :param parser: the CLI option parser
- :param group: an optional OptGroup object
- """
- container = self._get_argparse_container(parser, group)
- kwargs = self._get_argparse_kwargs(group)
- prefix = self._get_argparse_prefix('', group)
- self._add_to_argparse(container, self.name, self.short, kwargs, prefix,
- self.positional, self.deprecated_name)
-
- def _add_to_argparse(self, container, name, short, kwargs, prefix='',
- positional=False, deprecated_name=None):
- """Add an option to an argparse parser or group.
-
- :param container: an argparse._ArgumentGroup object
- :param name: the opt name
- :param short: the short opt name
- :param kwargs: the keyword arguments for add_argument()
- :param prefix: an optional prefix to prepend to the opt name
- :param position: whether the optional is a positional CLI argument
- :raises: DuplicateOptError if a naming confict is detected
- """
- def hyphen(arg):
- return arg if not positional else ''
-
- args = [hyphen('--') + prefix + name]
- if short:
- args.append(hyphen('-') + short)
- if deprecated_name:
- args.append(hyphen('--') + prefix + deprecated_name)
-
- try:
- container.add_argument(*args, **kwargs)
- except argparse.ArgumentError as e:
- raise DuplicateOptError(e)
-
- def _get_argparse_container(self, parser, group):
- """Returns an argparse._ArgumentGroup.
-
- :param parser: an argparse.ArgumentParser
- :param group: an (optional) OptGroup object
- :returns: an argparse._ArgumentGroup if group is given, else parser
- """
- if group is not None:
- return group._get_argparse_group(parser)
- else:
- return parser
-
- def _get_argparse_kwargs(self, group, **kwargs):
- """Build a dict of keyword arguments for argparse's add_argument().
-
- Most opt types extend this method to customize the behaviour of the
- options added to argparse.
-
- :param group: an optional group
- :param kwargs: optional keyword arguments to add to
- :returns: a dict of keyword arguments
- """
- if not self.positional:
- dest = self.dest
- if group is not None:
- dest = group.name + '_' + dest
- kwargs['dest'] = dest
- else:
- kwargs['nargs'] = '?'
- kwargs.update({'default': None,
- 'metavar': self.metavar,
- 'help': self.help, })
- return kwargs
-
- def _get_argparse_prefix(self, prefix, group):
- """Build a prefix for the CLI option name, if required.
-
- CLI options in a group are prefixed with the group's name in order
- to avoid conflicts between similarly named options in different
- groups.
-
- :param prefix: an existing prefix to append to (e.g. 'no' or '')
- :param group: an optional OptGroup object
- :returns: a CLI option prefix including the group name, if appropriate
- """
- if group is not None:
- return group.name + '-' + prefix
- else:
- return prefix
-
-
-class StrOpt(Opt):
- """
- String opts do not have their values transformed and are returned as
- str objects.
- """
- pass
-
-
-class BoolOpt(Opt):
-
- """
- Bool opts are set to True or False on the command line using --optname or
- --noopttname respectively.
-
- In config files, boolean values are case insensitive and can be set using
- 1/0, yes/no, true/false or on/off.
- """
-
- _boolean_states = {'1': True, 'yes': True, 'true': True, 'on': True,
- '0': False, 'no': False, 'false': False, 'off': False}
-
- def __init__(self, *args, **kwargs):
- if 'positional' in kwargs:
- raise ValueError('positional boolean args not supported')
- super(BoolOpt, self).__init__(*args, **kwargs)
-
- def _get_from_config_parser(self, cparser, section):
- """Retrieve the opt value as a boolean from ConfigParser."""
- def convert_bool(v):
- value = self._boolean_states.get(v.lower())
- if value is None:
- raise ValueError('Unexpected boolean value %r' % v)
-
- return value
-
- return [convert_bool(v) for v in
- self._cparser_get_with_deprecated(cparser, section)]
-
- def _add_to_cli(self, parser, group=None):
- """Extends the base class method to add the --nooptname option."""
- super(BoolOpt, self)._add_to_cli(parser, group)
- self._add_inverse_to_argparse(parser, group)
-
- def _add_inverse_to_argparse(self, parser, group):
- """Add the --nooptname option to the option parser."""
- container = self._get_argparse_container(parser, group)
- kwargs = self._get_argparse_kwargs(group, action='store_false')
- prefix = self._get_argparse_prefix('no', group)
- kwargs["help"] = "The inverse of --" + self.name
- self._add_to_argparse(container, self.name, None, kwargs, prefix,
- self.positional, self.deprecated_name)
-
- def _get_argparse_kwargs(self, group, action='store_true', **kwargs):
- """Extends the base argparse keyword dict for boolean options."""
-
- kwargs = super(BoolOpt, self)._get_argparse_kwargs(group, **kwargs)
-
- # metavar has no effect for BoolOpt
- if 'metavar' in kwargs:
- del kwargs['metavar']
-
- if action != 'store_true':
- action = 'store_false'
-
- kwargs['action'] = action
-
- return kwargs
-
-
-class IntOpt(Opt):
-
- """Int opt values are converted to integers using the int() builtin."""
-
- def _get_from_config_parser(self, cparser, section):
- """Retrieve the opt value as a integer from ConfigParser."""
- return [int(v) for v in self._cparser_get_with_deprecated(cparser,
- section)]
-
- def _get_argparse_kwargs(self, group, **kwargs):
- """Extends the base argparse keyword dict for integer options."""
- return super(IntOpt,
- self)._get_argparse_kwargs(group, type=int, **kwargs)
-
-
-class FloatOpt(Opt):
-
- """Float opt values are converted to floats using the float() builtin."""
-
- def _get_from_config_parser(self, cparser, section):
- """Retrieve the opt value as a float from ConfigParser."""
- return [float(v) for v in
- self._cparser_get_with_deprecated(cparser, section)]
-
- def _get_argparse_kwargs(self, group, **kwargs):
- """Extends the base argparse keyword dict for float options."""
- return super(FloatOpt, self)._get_argparse_kwargs(group,
- type=float, **kwargs)
-
-
-class ListOpt(Opt):
-
- """
- List opt values are simple string values separated by commas. The opt value
- is a list containing these strings.
- """
-
- class _StoreListAction(argparse.Action):
- """
- An argparse action for parsing an option value into a list.
- """
- def __call__(self, parser, namespace, values, option_string=None):
- if values is not None:
- values = [a.strip() for a in values.split(',')]
- setattr(namespace, self.dest, values)
-
- def _get_from_config_parser(self, cparser, section):
- """Retrieve the opt value as a list from ConfigParser."""
- return [[a.strip() for a in v.split(',')] for v in
- self._cparser_get_with_deprecated(cparser, section)]
-
- def _get_argparse_kwargs(self, group, **kwargs):
- """Extends the base argparse keyword dict for list options."""
- return Opt._get_argparse_kwargs(self,
- group,
- action=ListOpt._StoreListAction,
- **kwargs)
-
-
-class MultiStrOpt(Opt):
-
- """
- Multistr opt values are string opts which may be specified multiple times.
- The opt value is a list containing all the string values specified.
- """
- multi = True
-
- def _get_argparse_kwargs(self, group, **kwargs):
- """Extends the base argparse keyword dict for multi str options."""
- kwargs = super(MultiStrOpt, self)._get_argparse_kwargs(group)
- if not self.positional:
- kwargs['action'] = 'append'
- else:
- kwargs['nargs'] = '*'
- return kwargs
-
- def _cparser_get_with_deprecated(self, cparser, section):
- """If cannot find option as dest try deprecated_name alias."""
- if self.deprecated_name is not None:
- return cparser.get(section, [self.dest, self.deprecated_name],
- multi=True)
- return cparser.get(section, [self.dest], multi=True)
-
-
-class SubCommandOpt(Opt):
-
- """
- Sub-command options allow argparse sub-parsers to be used to parse
- additional command line arguments.
-
- The handler argument to the SubCommandOpt contructor is a callable
- which is supplied an argparse subparsers object. Use this handler
- callable to add sub-parsers.
-
- The opt value is SubCommandAttr object with the name of the chosen
- sub-parser stored in the 'name' attribute and the values of other
- sub-parser arguments available as additional attributes.
- """
-
- def __init__(self, name, dest=None, handler=None,
- title=None, description=None, help=None):
- """Construct an sub-command parsing option.
-
- This behaves similarly to other Opt sub-classes but adds a
- 'handler' argument. The handler is a callable which is supplied
- an subparsers object when invoked. The add_parser() method on
- this subparsers object can be used to register parsers for
- sub-commands.
-
- :param name: the option's name
- :param dest: the name of the corresponding ConfigOpts property
- :param title: title of the sub-commands group in help output
- :param description: description of the group in help output
- :param help: a help string giving an overview of available sub-commands
- """
- super(SubCommandOpt, self).__init__(name, dest=dest, help=help)
- self.handler = handler
- self.title = title
- self.description = description
-
- def _add_to_cli(self, parser, group=None):
- """Add argparse sub-parsers and invoke the handler method."""
- dest = self.dest
- if group is not None:
- dest = group.name + '_' + dest
-
- subparsers = parser.add_subparsers(dest=dest,
- title=self.title,
- description=self.description,
- help=self.help)
-
- if self.handler is not None:
- self.handler(subparsers)
-
-
-class OptGroup(object):
-
- """
- Represents a group of opts.
-
- CLI opts in the group are automatically prefixed with the group name.
-
- Each group corresponds to a section in config files.
-
- An OptGroup object has no public methods, but has a number of public string
- properties:
-
- name:
- the name of the group
- title:
- the group title as displayed in --help
- help:
- the group description as displayed in --help
- """
-
- def __init__(self, name, title=None, help=None):
- """Constructs an OptGroup object.
-
- :param name: the group name
- :param title: the group title for --help
- :param help: the group description for --help
- """
- self.name = name
- if title is None:
- self.title = "%s options" % title
- else:
- self.title = title
- self.help = help
-
- self._opts = {} # dict of dicts of (opt:, override:, default:)
- self._argparse_group = None
-
- def _register_opt(self, opt, cli=False):
- """Add an opt to this group.
-
- :param opt: an Opt object
- :param cli: whether this is a CLI option
- :returns: False if previously registered, True otherwise
- :raises: DuplicateOptError if a naming conflict is detected
- """
- if _is_opt_registered(self._opts, opt):
- return False
-
- self._opts[opt.dest] = {'opt': opt, 'cli': cli}
-
- return True
-
- def _unregister_opt(self, opt):
- """Remove an opt from this group.
-
- :param opt: an Opt object
- """
- if opt.dest in self._opts:
- del self._opts[opt.dest]
-
- def _get_argparse_group(self, parser):
- if self._argparse_group is None:
- """Build an argparse._ArgumentGroup for this group."""
- self._argparse_group = parser.add_argument_group(self.title,
- self.help)
- return self._argparse_group
-
- def _clear(self):
- """Clear this group's option parsing state."""
- self._argparse_group = None
-
-
-class ParseError(iniparser.ParseError):
- def __init__(self, msg, lineno, line, filename):
- super(ParseError, self).__init__(msg, lineno, line)
- self.filename = filename
-
- def __str__(self):
- return 'at %s:%d, %s: %r' % (self.filename, self.lineno,
- self.msg, self.line)
-
-
-class ConfigParser(iniparser.BaseParser):
- def __init__(self, filename, sections):
- super(ConfigParser, self).__init__()
- self.filename = filename
- self.sections = sections
- self.section = None
-
- def parse(self):
- with open(self.filename) as f:
- return super(ConfigParser, self).parse(f)
-
- def new_section(self, section):
- self.section = section
- self.sections.setdefault(self.section, {})
-
- def assignment(self, key, value):
- if not self.section:
- raise self.error_no_section()
-
- self.sections[self.section].setdefault(key, [])
- self.sections[self.section][key].append('\n'.join(value))
-
- def parse_exc(self, msg, lineno, line=None):
- return ParseError(msg, lineno, line, self.filename)
-
- def error_no_section(self):
- return self.parse_exc('Section must be started before assignment',
- self.lineno)
-
-
-class MultiConfigParser(object):
- def __init__(self):
- self.parsed = []
-
- def read(self, config_files):
- read_ok = []
-
- for filename in config_files:
- sections = {}
- parser = ConfigParser(filename, sections)
-
- try:
- parser.parse()
- except IOError:
- continue
- self.parsed.insert(0, sections)
- read_ok.append(filename)
-
- return read_ok
-
- def get(self, section, names, multi=False):
- rvalue = []
- for sections in self.parsed:
- if section not in sections:
- continue
- for name in names:
- if name in sections[section]:
- if multi:
- rvalue = sections[section][name] + rvalue
- else:
- return sections[section][name]
- if multi and rvalue != []:
- return rvalue
- raise KeyError
-
-
-class ConfigOpts(collections.Mapping):
-
- """
- Config options which may be set on the command line or in config files.
-
- ConfigOpts is a configuration option manager with APIs for registering
- option schemas, grouping options, parsing option values and retrieving
- the values of options.
- """
-
- def __init__(self):
- """Construct a ConfigOpts object."""
- self._opts = {} # dict of dicts of (opt:, override:, default:)
- self._groups = {}
-
- self._args = None
-
- self._oparser = None
- self._cparser = None
- self._cli_values = {}
- self.__cache = {}
- self._config_opts = []
-
- def _pre_setup(self, project, prog, version, usage, default_config_files):
- """Initialize a ConfigCliParser object for option parsing."""
-
- if prog is None:
- prog = os.path.basename(sys.argv[0])
-
- if default_config_files is None:
- default_config_files = find_config_files(project, prog)
-
- self._oparser = argparse.ArgumentParser(prog=prog, usage=usage)
- self._oparser.add_argument('--version',
- action='version',
- version=version)
-
- return prog, default_config_files
-
- def _setup(self, project, prog, version, usage, default_config_files):
- """Initialize a ConfigOpts object for option parsing."""
-
- self._config_opts = [
- MultiStrOpt('config-file',
- default=default_config_files,
- metavar='PATH',
- help='Path to a config file to use. Multiple config '
- 'files can be specified, with values in later '
- 'files taking precedence. The default files '
- ' used are: %s' % (default_config_files, )),
- StrOpt('config-dir',
- metavar='DIR',
- help='Path to a config directory to pull *.conf '
- 'files from. This file set is sorted, so as to '
- 'provide a predictable parse order if individual '
- 'options are over-ridden. The set is parsed after '
- 'the file(s), if any, specified via --config-file, '
- 'hence over-ridden options in the directory take '
- 'precedence.'),
- ]
- self.register_cli_opts(self._config_opts)
-
- self.project = project
- self.prog = prog
- self.version = version
- self.usage = usage
- self.default_config_files = default_config_files
-
- def __clear_cache(f):
- @functools.wraps(f)
- def __inner(self, *args, **kwargs):
- if kwargs.pop('clear_cache', True):
- self.__cache.clear()
- return f(self, *args, **kwargs)
-
- return __inner
-
- def __call__(self,
- args=None,
- project=None,
- prog=None,
- version=None,
- usage=None,
- default_config_files=None):
- """Parse command line arguments and config files.
-
- Calling a ConfigOpts object causes the supplied command line arguments
- and config files to be parsed, causing opt values to be made available
- as attributes of the object.
-
- The object may be called multiple times, each time causing the previous
- set of values to be overwritten.
-
- Automatically registers the --config-file option with either a supplied
- list of default config files, or a list from find_config_files().
-
- If the --config-dir option is set, any *.conf files from this
- directory are pulled in, after all the file(s) specified by the
- --config-file option.
-
- :param args: command line arguments (defaults to sys.argv[1:])
- :param project: the toplevel project name, used to locate config files
- :param prog: the name of the program (defaults to sys.argv[0] basename)
- :param version: the program version (for --version)
- :param usage: a usage string (%prog will be expanded)
- :param default_config_files: config files to use by default
- :returns: the list of arguments left over after parsing options
- :raises: SystemExit, ConfigFilesNotFoundError, ConfigFileParseError,
- RequiredOptError, DuplicateOptError
- """
-
- self.clear()
-
- prog, default_config_files = self._pre_setup(project,
- prog,
- version,
- usage,
- default_config_files)
-
- self._setup(project, prog, version, usage, default_config_files)
-
- self._cli_values = self._parse_cli_opts(args)
-
- self._parse_config_files()
-
- self._check_required_opts()
-
- def __getattr__(self, name):
- """Look up an option value and perform string substitution.
-
- :param name: the opt name (or 'dest', more precisely)
- :returns: the option value (after string subsititution) or a GroupAttr
- :raises: NoSuchOptError,ConfigFileValueError,TemplateSubstitutionError
- """
- return self._get(name)
-
- def __getitem__(self, key):
- """Look up an option value and perform string substitution."""
- return self.__getattr__(key)
-
- def __contains__(self, key):
- """Return True if key is the name of a registered opt or group."""
- return key in self._opts or key in self._groups
-
- def __iter__(self):
- """Iterate over all registered opt and group names."""
- for key in self._opts.keys() + self._groups.keys():
- yield key
-
- def __len__(self):
- """Return the number of options and option groups."""
- return len(self._opts) + len(self._groups)
-
- def reset(self):
- """Clear the object state and unset overrides and defaults."""
- self._unset_defaults_and_overrides()
- self.clear()
-
- @__clear_cache
- def clear(self):
- """Clear the state of the object to before it was called.
-
- Any subparsers added using the add_cli_subparsers() will also be
- removed as a side-effect of this method.
- """
- self._args = None
- self._cli_values.clear()
- self._oparser = argparse.ArgumentParser()
- self._cparser = None
- self.unregister_opts(self._config_opts)
- for group in self._groups.values():
- group._clear()
-
- @__clear_cache
- def register_opt(self, opt, group=None, cli=False):
- """Register an option schema.
-
- Registering an option schema makes any option value which is previously
- or subsequently parsed from the command line or config files available
- as an attribute of this object.
-
- :param opt: an instance of an Opt sub-class
- :param cli: whether this is a CLI option
- :param group: an optional OptGroup object or group name
- :return: False if the opt was already register, True otherwise
- :raises: DuplicateOptError
- """
- if group is not None:
- group = self._get_group(group, autocreate=True)
- return group._register_opt(opt, cli)
-
- if _is_opt_registered(self._opts, opt):
- return False
-
- self._opts[opt.dest] = {'opt': opt, 'cli': cli}
-
- return True
-
- @__clear_cache
- def register_opts(self, opts, group=None):
- """Register multiple option schemas at once."""
- for opt in opts:
- self.register_opt(opt, group, clear_cache=False)
-
- @__clear_cache
- def register_cli_opt(self, opt, group=None):
- """Register a CLI option schema.
-
- CLI option schemas must be registered before the command line and
- config files are parsed. This is to ensure that all CLI options are
- show in --help and option validation works as expected.
-
- :param opt: an instance of an Opt sub-class
- :param group: an optional OptGroup object or group name
- :return: False if the opt was already register, True otherwise
- :raises: DuplicateOptError, ArgsAlreadyParsedError
- """
- if self._args is not None:
- raise ArgsAlreadyParsedError("cannot register CLI option")
-
- return self.register_opt(opt, group, cli=True, clear_cache=False)
-
- @__clear_cache
- def register_cli_opts(self, opts, group=None):
- """Register multiple CLI option schemas at once."""
- for opt in opts:
- self.register_cli_opt(opt, group, clear_cache=False)
-
- def register_group(self, group):
- """Register an option group.
-
- An option group must be registered before options can be registered
- with the group.
-
- :param group: an OptGroup object
- """
- if group.name in self._groups:
- return
-
- self._groups[group.name] = copy.copy(group)
-
- @__clear_cache
- def unregister_opt(self, opt, group=None):
- """Unregister an option.
-
- :param opt: an Opt object
- :param group: an optional OptGroup object or group name
- :raises: ArgsAlreadyParsedError, NoSuchGroupError
- """
- if self._args is not None:
- raise ArgsAlreadyParsedError("reset before unregistering options")
-
- if group is not None:
- self._get_group(group)._unregister_opt(opt)
- elif opt.dest in self._opts:
- del self._opts[opt.dest]
-
- @__clear_cache
- def unregister_opts(self, opts, group=None):
- """Unregister multiple CLI option schemas at once."""
- for opt in opts:
- self.unregister_opt(opt, group, clear_cache=False)
-
- def import_opt(self, name, module_str, group=None):
- """Import an option definition from a module.
-
- Import a module and check that a given option is registered.
-
- This is intended for use with global configuration objects
- like cfg.CONF where modules commonly register options with
- CONF at module load time. If one module requires an option
- defined by another module it can use this method to explicitly
- declare the dependency.
-
- :param name: the name/dest of the opt
- :param module_str: the name of a module to import
- :param group: an option OptGroup object or group name
- :raises: NoSuchOptError, NoSuchGroupError
- """
- __import__(module_str)
- self._get_opt_info(name, group)
-
- def import_group(self, group, module_str):
- """Import an option group from a module.
-
- Import a module and check that a given option group is registered.
-
- This is intended for use with global configuration objects
- like cfg.CONF where modules commonly register options with
- CONF at module load time. If one module requires an option group
- defined by another module it can use this method to explicitly
- declare the dependency.
-
- :param group: an option OptGroup object or group name
- :param module_str: the name of a module to import
- :raises: ImportError, NoSuchGroupError
- """
- __import__(module_str)
- self._get_group(group)
-
- @__clear_cache
- def set_override(self, name, override, group=None):
- """Override an opt value.
-
- Override the command line, config file and default values of a
- given option.
-
- :param name: the name/dest of the opt
- :param override: the override value
- :param group: an option OptGroup object or group name
- :raises: NoSuchOptError, NoSuchGroupError
- """
- opt_info = self._get_opt_info(name, group)
- opt_info['override'] = override
-
- @__clear_cache
- def set_default(self, name, default, group=None):
- """Override an opt's default value.
-
- Override the default value of given option. A command line or
- config file value will still take precedence over this default.
-
- :param name: the name/dest of the opt
- :param default: the default value
- :param group: an option OptGroup object or group name
- :raises: NoSuchOptError, NoSuchGroupError
- """
- opt_info = self._get_opt_info(name, group)
- opt_info['default'] = default
-
- @__clear_cache
- def clear_override(self, name, group=None):
- """Clear an override an opt value.
-
- Clear a previously set override of the command line, config file
- and default values of a given option.
-
- :param name: the name/dest of the opt
- :param group: an option OptGroup object or group name
- :raises: NoSuchOptError, NoSuchGroupError
- """
- opt_info = self._get_opt_info(name, group)
- opt_info.pop('override', None)
-
- @__clear_cache
- def clear_default(self, name, group=None):
- """Clear an override an opt's default value.
-
- Clear a previously set override of the default value of given option.
-
- :param name: the name/dest of the opt
- :param group: an option OptGroup object or group name
- :raises: NoSuchOptError, NoSuchGroupError
- """
- opt_info = self._get_opt_info(name, group)
- opt_info.pop('default', None)
-
- def _all_opt_infos(self):
- """A generator function for iteration opt infos."""
- for info in self._opts.values():
- yield info, None
- for group in self._groups.values():
- for info in group._opts.values():
- yield info, group
-
- def _all_cli_opts(self):
- """A generator function for iterating CLI opts."""
- for info, group in self._all_opt_infos():
- if info['cli']:
- yield info['opt'], group
-
- def _unset_defaults_and_overrides(self):
- """Unset any default or override on all options."""
- for info, group in self._all_opt_infos():
- info.pop('default', None)
- info.pop('override', None)
-
- def find_file(self, name):
- """Locate a file located alongside the config files.
-
- Search for a file with the supplied basename in the directories
- which we have already loaded config files from and other known
- configuration directories.
-
- The directory, if any, supplied by the config_dir option is
- searched first. Then the config_file option is iterated over
- and each of the base directories of the config_files values
- are searched. Failing both of these, the standard directories
- searched by the module level find_config_files() function is
- used. The first matching file is returned.
-
- :param basename: the filename, e.g. 'policy.json'
- :returns: the path to a matching file, or None
- """
- dirs = []
- if self.config_dir:
- dirs.append(_fixpath(self.config_dir))
-
- for cf in reversed(self.config_file):
- dirs.append(os.path.dirname(_fixpath(cf)))
-
- dirs.extend(_get_config_dirs(self.project))
-
- return _search_dirs(dirs, name)
-
- def log_opt_values(self, logger, lvl):
- """Log the value of all registered opts.
-
- It's often useful for an app to log its configuration to a log file at
- startup for debugging. This method dumps to the entire config state to
- the supplied logger at a given log level.
-
- :param logger: a logging.Logger object
- :param lvl: the log level (e.g. logging.DEBUG) arg to logger.log()
- """
- logger.log(lvl, "*" * 80)
- logger.log(lvl, "Configuration options gathered from:")
- logger.log(lvl, "command line args: %s", self._args)
- logger.log(lvl, "config files: %s", self.config_file)
- logger.log(lvl, "=" * 80)
-
- def _sanitize(opt, value):
- """Obfuscate values of options declared secret."""
- return value if not opt.secret else '*' * len(str(value))
-
- for opt_name in sorted(self._opts):
- opt = self._get_opt_info(opt_name)['opt']
- logger.log(lvl, "%-30s = %s", opt_name,
- _sanitize(opt, getattr(self, opt_name)))
-
- for group_name in self._groups:
- group_attr = self.GroupAttr(self, self._get_group(group_name))
- for opt_name in sorted(self._groups[group_name]._opts):
- opt = self._get_opt_info(opt_name, group_name)['opt']
- logger.log(lvl, "%-30s = %s",
- "%s.%s" % (group_name, opt_name),
- _sanitize(opt, getattr(group_attr, opt_name)))
-
- logger.log(lvl, "*" * 80)
-
- def print_usage(self, file=None):
- """Print the usage message for the current program."""
- self._oparser.print_usage(file)
-
- def print_help(self, file=None):
- """Print the help message for the current program."""
- self._oparser.print_help(file)
-
- def _get(self, name, group=None):
- if isinstance(group, OptGroup):
- key = (group.name, name)
- else:
- key = (group, name)
- try:
- return self.__cache[key]
- except KeyError:
- value = self._substitute(self._do_get(name, group))
- self.__cache[key] = value
- return value
-
- def _do_get(self, name, group=None):
- """Look up an option value.
-
- :param name: the opt name (or 'dest', more precisely)
- :param group: an OptGroup
- :returns: the option value, or a GroupAttr object
- :raises: NoSuchOptError, NoSuchGroupError, ConfigFileValueError,
- TemplateSubstitutionError
- """
- if group is None and name in self._groups:
- return self.GroupAttr(self, self._get_group(name))
-
- info = self._get_opt_info(name, group)
- opt = info['opt']
-
- if isinstance(opt, SubCommandOpt):
- return self.SubCommandAttr(self, group, opt.dest)
-
- if 'override' in info:
- return info['override']
-
- values = []
- if self._cparser is not None:
- section = group.name if group is not None else 'DEFAULT'
- try:
- value = opt._get_from_config_parser(self._cparser, section)
- except KeyError:
- pass
- except ValueError as ve:
- raise ConfigFileValueError(str(ve))
- else:
- if not opt.multi:
- # No need to continue since the last value wins
- return value[-1]
- values.extend(value)
-
- name = name if group is None else group.name + '_' + name
- value = self._cli_values.get(name)
- if value is not None:
- if not opt.multi:
- return value
-
- # argparse ignores default=None for nargs='*'
- if opt.positional and not value:
- value = opt.default
-
- return value + values
-
- if values:
- return values
-
- if 'default' in info:
- return info['default']
-
- return opt.default
-
- def _substitute(self, value):
- """Perform string template substitution.
-
- Substitute any template variables (e.g. $foo, ${bar}) in the supplied
- string value(s) with opt values.
-
- :param value: the string value, or list of string values
- :returns: the substituted string(s)
- """
- if isinstance(value, list):
- return [self._substitute(i) for i in value]
- elif isinstance(value, str):
- tmpl = string.Template(value)
- return tmpl.safe_substitute(self.StrSubWrapper(self))
- else:
- return value
-
- def _get_group(self, group_or_name, autocreate=False):
- """Looks up a OptGroup object.
-
- Helper function to return an OptGroup given a parameter which can
- either be the group's name or an OptGroup object.
-
- The OptGroup object returned is from the internal dict of OptGroup
- objects, which will be a copy of any OptGroup object that users of
- the API have access to.
-
- :param group_or_name: the group's name or the OptGroup object itself
- :param autocreate: whether to auto-create the group if it's not found
- :raises: NoSuchGroupError
- """
- group = group_or_name if isinstance(group_or_name, OptGroup) else None
- group_name = group.name if group else group_or_name
-
- if group_name not in self._groups:
- if group is not None or not autocreate:
- raise NoSuchGroupError(group_name)
-
- self.register_group(OptGroup(name=group_name))
-
- return self._groups[group_name]
-
- def _get_opt_info(self, opt_name, group=None):
- """Return the (opt, override, default) dict for an opt.
-
- :param opt_name: an opt name/dest
- :param group: an optional group name or OptGroup object
- :raises: NoSuchOptError, NoSuchGroupError
- """
- if group is None:
- opts = self._opts
- else:
- group = self._get_group(group)
- opts = group._opts
-
- if opt_name not in opts:
- raise NoSuchOptError(opt_name, group)
-
- return opts[opt_name]
-
- def _parse_config_files(self):
- """Parse the config files from --config-file and --config-dir.
-
- :raises: ConfigFilesNotFoundError, ConfigFileParseError
- """
- config_files = list(self.config_file)
-
- if self.config_dir:
- config_dir_glob = os.path.join(self.config_dir, '*.conf')
- config_files += sorted(glob.glob(config_dir_glob))
-
- config_files = [_fixpath(p) for p in config_files]
-
- self._cparser = MultiConfigParser()
-
- try:
- read_ok = self._cparser.read(config_files)
- except iniparser.ParseError as pe:
- raise ConfigFileParseError(pe.filename, str(pe))
-
- if read_ok != config_files:
- not_read_ok = filter(lambda f: f not in read_ok, config_files)
- raise ConfigFilesNotFoundError(not_read_ok)
-
- def _check_required_opts(self):
- """Check that all opts marked as required have values specified.
-
- :raises: RequiredOptError
- """
- for info, group in self._all_opt_infos():
- opt = info['opt']
-
- if opt.required:
- if 'default' in info or 'override' in info:
- continue
-
- if self._get(opt.dest, group) is None:
- raise RequiredOptError(opt.name, group)
-
- def _parse_cli_opts(self, args):
- """Parse command line options.
-
- Initializes the command line option parser and parses the supplied
- command line arguments.
-
- :param args: the command line arguments
- :returns: a dict of parsed option values
- :raises: SystemExit, DuplicateOptError
-
- """
- self._args = args
-
- for opt, group in sorted(self._all_cli_opts()):
- opt._add_to_cli(self._oparser, group)
-
- return vars(self._oparser.parse_args(args))
-
- class GroupAttr(collections.Mapping):
-
- """
- A helper class representing the option values of a group as a mapping
- and attributes.
- """
-
- def __init__(self, conf, group):
- """Construct a GroupAttr object.
-
- :param conf: a ConfigOpts object
- :param group: an OptGroup object
- """
- self._conf = conf
- self._group = group
-
- def __getattr__(self, name):
- """Look up an option value and perform template substitution."""
- return self._conf._get(name, self._group)
-
- def __getitem__(self, key):
- """Look up an option value and perform string substitution."""
- return self.__getattr__(key)
-
- def __contains__(self, key):
- """Return True if key is the name of a registered opt or group."""
- return key in self._group._opts
-
- def __iter__(self):
- """Iterate over all registered opt and group names."""
- for key in self._group._opts.keys():
- yield key
-
- def __len__(self):
- """Return the number of options and option groups."""
- return len(self._group._opts)
-
- class SubCommandAttr(object):
-
- """
- A helper class representing the name and arguments of an argparse
- sub-parser.
- """
-
- def __init__(self, conf, group, dest):
- """Construct a SubCommandAttr object.
-
- :param conf: a ConfigOpts object
- :param group: an OptGroup object
- :param dest: the name of the sub-parser
- """
- self._conf = conf
- self._group = group
- self._dest = dest
-
- def __getattr__(self, name):
- """Look up a sub-parser name or argument value."""
- if name == 'name':
- name = self._dest
- if self._group is not None:
- name = self._group.name + '_' + name
- return self._conf._cli_values[name]
-
- if name in self._conf:
- raise DuplicateOptError(name)
-
- try:
- return self._conf._cli_values[name]
- except KeyError:
- raise NoSuchOptError(name)
-
- class StrSubWrapper(object):
-
- """
- A helper class exposing opt values as a dict for string substitution.
- """
-
- def __init__(self, conf):
- """Construct a StrSubWrapper object.
-
- :param conf: a ConfigOpts object
- """
- self.conf = conf
-
- def __getitem__(self, key):
- """Look up an opt value from the ConfigOpts object.
-
- :param key: an opt name
- :returns: an opt value
- :raises: TemplateSubstitutionError if attribute is a group
- """
- value = getattr(self.conf, key)
- if isinstance(value, self.conf.GroupAttr):
- raise TemplateSubstitutionError(
- 'substituting group %s not supported' % key)
- return value
-
-
-CONF = ConfigOpts()
diff --git a/tempest/openstack/common/iniparser.py b/tempest/openstack/common/iniparser.py
deleted file mode 100644
index 9a8762a..0000000
--- a/tempest/openstack/common/iniparser.py
+++ /dev/null
@@ -1,130 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2012 OpenStack LLC.
-#
-# 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.
-
-
-class ParseError(Exception):
- def __init__(self, message, lineno, line):
- self.msg = message
- self.line = line
- self.lineno = lineno
-
- def __str__(self):
- return 'at line %d, %s: %r' % (self.lineno, self.msg, self.line)
-
-
-class BaseParser(object):
- lineno = 0
- parse_exc = ParseError
-
- def _assignment(self, key, value):
- self.assignment(key, value)
- return None, []
-
- def _get_section(self, line):
- if line[-1] != ']':
- return self.error_no_section_end_bracket(line)
- if len(line) <= 2:
- return self.error_no_section_name(line)
-
- return line[1:-1]
-
- def _split_key_value(self, line):
- colon = line.find(':')
- equal = line.find('=')
- if colon < 0 and equal < 0:
- return self.error_invalid_assignment(line)
-
- if colon < 0 or (equal >= 0 and equal < colon):
- key, value = line[:equal], line[equal + 1:]
- else:
- key, value = line[:colon], line[colon + 1:]
-
- value = value.strip()
- if ((value and value[0] == value[-1]) and
- (value[0] == "\"" or value[0] == "'")):
- value = value[1:-1]
- return key.strip(), [value]
-
- def parse(self, lineiter):
- key = None
- value = []
-
- for line in lineiter:
- self.lineno += 1
-
- line = line.rstrip()
- if not line:
- # Blank line, ends multi-line values
- if key:
- key, value = self._assignment(key, value)
- continue
- elif line[0] in (' ', '\t'):
- # Continuation of previous assignment
- if key is None:
- self.error_unexpected_continuation(line)
- else:
- value.append(line.lstrip())
- continue
-
- if key:
- # Flush previous assignment, if any
- key, value = self._assignment(key, value)
-
- if line[0] == '[':
- # Section start
- section = self._get_section(line)
- if section:
- self.new_section(section)
- elif line[0] in '#;':
- self.comment(line[1:].lstrip())
- else:
- key, value = self._split_key_value(line)
- if not key:
- return self.error_empty_key(line)
-
- if key:
- # Flush previous assignment, if any
- self._assignment(key, value)
-
- def assignment(self, key, value):
- """Called when a full assignment is parsed."""
- raise NotImplementedError()
-
- def new_section(self, section):
- """Called when a new section is started."""
- raise NotImplementedError()
-
- def comment(self, comment):
- """Called when a comment is parsed."""
- pass
-
- def error_invalid_assignment(self, line):
- raise self.parse_exc("No ':' or '=' found in assignment",
- self.lineno, line)
-
- def error_empty_key(self, line):
- raise self.parse_exc('Key cannot be empty', self.lineno, line)
-
- def error_unexpected_continuation(self, line):
- raise self.parse_exc('Unexpected continuation line',
- self.lineno, line)
-
- def error_no_section_end_bracket(self, line):
- raise self.parse_exc('Invalid section (must end with ])',
- self.lineno, line)
-
- def error_no_section_name(self, line):
- raise self.parse_exc('Empty section name', self.lineno, line)
diff --git a/tempest/openstack/common/setup.py b/tempest/openstack/common/setup.py
index 2fb9cf2..80a0ece 100644
--- a/tempest/openstack/common/setup.py
+++ b/tempest/openstack/common/setup.py
@@ -43,6 +43,11 @@
return mapping
+def _parse_git_mailmap(git_dir, mailmap='.mailmap'):
+ mailmap = os.path.join(os.path.dirname(git_dir), mailmap)
+ return parse_mailmap(mailmap)
+
+
def canonicalize_emails(changelog, mapping):
"""Takes in a string and an email alias mapping and replaces all
instances of the aliases in the string with their real email.
@@ -117,9 +122,9 @@
output = subprocess.Popen(["/bin/sh", "-c", cmd],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
+ out = output.communicate()
if output.returncode and throw_on_error:
raise Exception("%s returned %d" % cmd, output.returncode)
- out = output.communicate()
if len(out) == 0:
return None
if len(out[0].strip()) == 0:
@@ -127,14 +132,26 @@
return out[0].strip()
+def _get_git_directory():
+ parent_dir = os.path.dirname(__file__)
+ while True:
+ git_dir = os.path.join(parent_dir, '.git')
+ if os.path.exists(git_dir):
+ return git_dir
+ parent_dir, child = os.path.split(parent_dir)
+ if not child: # reached to root dir
+ return None
+
+
def write_git_changelog():
"""Write a changelog based on the git changelog."""
new_changelog = 'ChangeLog'
+ git_dir = _get_git_directory()
if not os.getenv('SKIP_WRITE_GIT_CHANGELOG'):
- if os.path.isdir('.git'):
- git_log_cmd = 'git log --stat'
+ if git_dir:
+ git_log_cmd = 'git --git-dir=%s log --stat' % git_dir
changelog = _run_shell_command(git_log_cmd)
- mailmap = parse_mailmap()
+ mailmap = _parse_git_mailmap(git_dir)
with open(new_changelog, "w") as changelog_file:
changelog_file.write(canonicalize_emails(changelog, mailmap))
else:
@@ -146,13 +163,15 @@
jenkins_email = 'jenkins@review.(openstack|stackforge).org'
old_authors = 'AUTHORS.in'
new_authors = 'AUTHORS'
+ git_dir = _get_git_directory()
if not os.getenv('SKIP_GENERATE_AUTHORS'):
- if os.path.isdir('.git'):
+ if git_dir:
# don't include jenkins email address in AUTHORS file
- git_log_cmd = ("git log --format='%aN <%aE>' | sort -u | "
+ git_log_cmd = ("git --git-dir=" + git_dir +
+ " log --format='%aN <%aE>' | sort -u | "
"egrep -v '" + jenkins_email + "'")
changelog = _run_shell_command(git_log_cmd)
- mailmap = parse_mailmap()
+ mailmap = _parse_git_mailmap(git_dir)
with open(new_authors, 'w') as new_authors_fh:
new_authors_fh.write(canonicalize_emails(changelog, mailmap))
if os.path.exists(old_authors):
@@ -258,40 +277,44 @@
return cmdclass
-def _get_revno():
+def _get_revno(git_dir):
"""Return the number of commits since the most recent tag.
We use git-describe to find this out, but if there are no
tags then we fall back to counting commits since the beginning
of time.
"""
- describe = _run_shell_command("git describe --always")
+ describe = _run_shell_command(
+ "git --git-dir=%s describe --always" % git_dir)
if "-" in describe:
return describe.rsplit("-", 2)[-2]
# no tags found
- revlist = _run_shell_command("git rev-list --abbrev-commit HEAD")
+ revlist = _run_shell_command(
+ "git --git-dir=%s rev-list --abbrev-commit HEAD" % git_dir)
return len(revlist.splitlines())
def _get_version_from_git(pre_version):
"""Return a version which is equal to the tag that's on the current
revision if there is one, or tag plus number of additional revisions
- if the current revision has no tag.
- """
+ if the current revision has no tag."""
- if os.path.isdir('.git'):
+ git_dir = _get_git_directory()
+ if git_dir:
if pre_version:
try:
return _run_shell_command(
- "git describe --exact-match",
+ "git --git-dir=" + git_dir + " describe --exact-match",
throw_on_error=True).replace('-', '.')
except Exception:
- sha = _run_shell_command("git log -n1 --pretty=format:%h")
- return "%s.a%s.g%s" % (pre_version, _get_revno(), sha)
+ sha = _run_shell_command(
+ "git --git-dir=" + git_dir + " log -n1 --pretty=format:%h")
+ return "%s.a%s.g%s" % (pre_version, _get_revno(git_dir), sha)
else:
return _run_shell_command(
- "git describe --always").replace('-', '.')
+ "git --git-dir=" + git_dir + " describe --always").replace(
+ '-', '.')
return None
diff --git a/tempest/services/botoclients.py b/tempest/services/botoclients.py
index 143257a..0870c96 100644
--- a/tempest/services/botoclients.py
+++ b/tempest/services/botoclients.py
@@ -17,7 +17,6 @@
import ConfigParser
import contextlib
-import re
import types
import urlparse
diff --git a/tempest/services/compute/json/interfaces_client.py b/tempest/services/compute/json/interfaces_client.py
new file mode 100644
index 0000000..468a5c2
--- /dev/null
+++ b/tempest/services/compute/json/interfaces_client.py
@@ -0,0 +1,57 @@
+# Copyright 2013 IBM Corp.
+# 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 json
+
+from tempest.common.rest_client import RestClient
+
+
+class InterfacesClientJSON(RestClient):
+
+ def __init__(self, config, username, password, auth_url, tenant_name=None):
+ super(InterfacesClientJSON, self).__init__(config, username, password,
+ auth_url, tenant_name)
+ self.service = self.config.compute.catalog_type
+
+ def list_interfaces(self, server):
+ resp, body = self.get('servers/%s/os-interface' % server)
+ body = json.loads(body)
+ return resp, body['interfaceAttachments']
+
+ def create_interface(self, server, port_id=None, network_id=None,
+ fixed_ip=None):
+ post_body = dict(interfaceAttachment=dict())
+ if port_id:
+ post_body['port_id'] = port_id
+ if network_id:
+ post_body['net_id'] = network_id
+ if fixed_ip:
+ post_body['fixed_ips'] = [dict(ip_address=fixed_ip)]
+ post_body = json.dumps(post_body)
+ resp, body = self.post('servers/%s/os-interface' % server,
+ headers=self.headers,
+ body=post_body)
+ body = json.loads(body)
+ return resp, body['interfaceAttachment']
+
+ def show_interface(self, server, port_id):
+ resp, body = self.get('servers/%s/os-interface/%s' % (server, port_id))
+ body = json.loads(body)
+ return resp, body['interfaceAttachment']
+
+ def delete_interface(self, server, port_id):
+ resp, body = self.delete('servers/%s/os-interface/%s' % (server,
+ port_id))
+ return resp, body
diff --git a/tempest/services/compute/json/volumes_extensions_client.py b/tempest/services/compute/json/volumes_extensions_client.py
index e4271d9..d12b97b 100644
--- a/tempest/services/compute/json/volumes_extensions_client.py
+++ b/tempest/services/compute/json/volumes_extensions_client.py
@@ -53,10 +53,10 @@
body = json.loads(body)
return resp, body['volumes']
- def get_volume(self, volume_id, wait=None):
+ def get_volume(self, volume_id):
"""Returns the details of a single volume."""
url = "os-volumes/%s" % str(volume_id)
- resp, body = self.get(url, wait=wait)
+ resp, body = self.get(url)
body = json.loads(body)
return resp, body['volume']
diff --git a/tempest/services/compute/xml/interfaces_client.py b/tempest/services/compute/xml/interfaces_client.py
new file mode 100644
index 0000000..4a692a1
--- /dev/null
+++ b/tempest/services/compute/xml/interfaces_client.py
@@ -0,0 +1,82 @@
+# Copyright 2013 IBM Corp.
+# 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.
+
+from lxml import etree
+
+from tempest.common.rest_client import RestClientXML
+from tempest.services.compute.xml.common import Document
+from tempest.services.compute.xml.common import Element
+from tempest.services.compute.xml.common import Text
+from tempest.services.compute.xml.common import xml_to_json
+
+
+class InterfacesClientXML(RestClientXML):
+
+ def __init__(self, config, username, password, auth_url, tenant_name=None):
+ super(InterfacesClientXML, self).__init__(config, username, password,
+ auth_url, tenant_name)
+ self.service = self.config.compute.catalog_type
+
+ def _process_xml_interface(self, node):
+ iface = xml_to_json(node)
+ # NOTE(danms): if multiple addresses per interface is ever required,
+ # xml_to_json will need to be fixed or replaced in this case
+ iface['fixed_ips'] = [dict(iface['fixed_ips']['fixed_ip'].items())]
+ return iface
+
+ def list_interfaces(self, server):
+ resp, body = self.get('servers/%s/os-interface' % server, self.headers)
+ node = etree.fromstring(body)
+ interfaces = [self._process_xml_interface(x)
+ for x in node.getchildren()]
+ return resp, interfaces
+
+ def create_interface(self, server, port_id=None, network_id=None,
+ fixed_ip=None):
+ doc = Document()
+ iface = Element('interfaceAttachment')
+ if port_id:
+ _port_id = Element('port_id')
+ _port_id.append(Text(port_id))
+ iface.append(_port_id)
+ if network_id:
+ _network_id = Element('net_id')
+ _network_id.append(Text(network_id))
+ iface.append(_network_id)
+ if fixed_ip:
+ _fixed_ips = Element('fixed_ips')
+ _fixed_ip = Element('fixed_ip')
+ _ip_address = Element('ip_address')
+ _ip_address.append(Text(fixed_ip))
+ _fixed_ip.append(_ip_address)
+ _fixed_ips.append(_fixed_ip)
+ iface.append(_fixed_ips)
+ doc.append(iface)
+ resp, body = self.post('servers/%s/os-interface' % server,
+ headers=self.headers,
+ body=str(doc))
+ body = self._process_xml_interface(etree.fromstring(body))
+ return resp, body
+
+ def show_interface(self, server, port_id):
+ resp, body = self.get('servers/%s/os-interface/%s' % (server, port_id),
+ self.headers)
+ body = self._process_xml_interface(etree.fromstring(body))
+ return resp, body
+
+ def delete_interface(self, server, port_id):
+ resp, body = self.delete('servers/%s/os-interface/%s' % (server,
+ port_id))
+ return resp, body
diff --git a/tempest/services/compute/xml/servers_client.py b/tempest/services/compute/xml/servers_client.py
index b0e4ce8..655a345 100644
--- a/tempest/services/compute/xml/servers_client.py
+++ b/tempest/services/compute/xml/servers_client.py
@@ -183,13 +183,13 @@
server = Element("server")
doc.append(server)
- if name:
+ if name is not None:
server.add_attr("name", name)
- if accessIPv4:
+ if accessIPv4 is not None:
server.add_attr("accessIPv4", accessIPv4)
- if accessIPv6:
+ if accessIPv6 is not None:
server.add_attr("accessIPv6", accessIPv6)
- if meta:
+ if meta is not None:
metadata = Element("metadata")
server.append(metadata)
for k, v in meta:
@@ -229,10 +229,26 @@
flavorRef=flavor_ref,
name=name)
- for attr in ["adminPass", "accessIPv4", "accessIPv6", "key_name"]:
+ for attr in ["adminPass", "accessIPv4", "accessIPv6", "key_name",
+ "user_data", "availability_zone"]:
if attr in kwargs:
server.add_attr(attr, kwargs[attr])
+ if 'security_groups' in kwargs:
+ secgroups = Element("security_groups")
+ server.append(secgroups)
+ for secgroup in kwargs['security_groups']:
+ s = Element("security_group", name=secgroup['name'])
+ secgroups.append(s)
+
+ if 'networks' in kwargs:
+ networks = Element("networks")
+ server.append(networks)
+ for network in kwargs['networks']:
+ s = Element("network", uuid=network['uuid'],
+ fixed_ip=network['fixed_ip'])
+ networks.append(s)
+
if 'meta' in kwargs:
metadata = Element("metadata")
server.append(metadata)
@@ -306,7 +322,8 @@
resp, body = self.get("servers/%s/ips" % str(server_id), self.headers)
networks = {}
- for child in etree.fromstring(body.getchildren()):
+ xml_list = etree.fromstring(body)
+ for child in xml_list.getchildren():
network = self._parse_network(child)
networks.update(**network)
@@ -384,6 +401,58 @@
def remove_security_group(self, server_id, name):
return self.action(server_id, 'removeSecurityGroup', None, name=name)
+ def list_server_metadata(self, server_id):
+ resp, body = self.get("servers/%s/metadata" % str(server_id),
+ self.headers)
+ body = self._parse_key_value(etree.fromstring(body))
+ return resp, body
+
+ def set_server_metadata(self, server_id, meta):
+ doc = Document()
+ metadata = Element("metadata")
+ doc.append(metadata)
+ for k, v in meta.items():
+ meta_element = Element("meta", key=k)
+ meta_element.append(Text(v))
+ metadata.append(meta_element)
+ resp, body = self.put('servers/%s/metadata' % str(server_id),
+ str(doc), self.headers)
+ return resp, xml_to_json(etree.fromstring(body))
+
+ def update_server_metadata(self, server_id, meta):
+ doc = Document()
+ metadata = Element("metadata")
+ doc.append(metadata)
+ for k, v in meta.items():
+ meta_element = Element("meta", key=k)
+ meta_element.append(Text(v))
+ metadata.append(meta_element)
+ resp, body = self.post("/servers/%s/metadata" % str(server_id),
+ str(doc), headers=self.headers)
+ body = xml_to_json(etree.fromstring(body))
+ return resp, body
+
+ def get_server_metadata_item(self, server_id, key):
+ resp, body = self.get("servers/%s/metadata/%s" % (str(server_id), key),
+ headers=self.headers)
+ return resp, dict([(etree.fromstring(body).attrib['key'],
+ xml_to_json(etree.fromstring(body)))])
+
+ def set_server_metadata_item(self, server_id, key, meta):
+ doc = Document()
+ for k, v in meta.items():
+ meta_element = Element("meta", key=k)
+ meta_element.append(Text(v))
+ doc.append(meta_element)
+ resp, body = self.put('servers/%s/metadata/%s' % (str(server_id), key),
+ str(doc), self.headers)
+ return resp, xml_to_json(etree.fromstring(body))
+
+ def delete_server_metadata_item(self, server_id, key):
+ resp, body = self.delete("servers/%s/metadata/%s" %
+ (str(server_id), key))
+ return resp, body
+
def get_console_output(self, server_id, length):
return self.action(server_id, 'os-getConsoleOutput', 'output',
length=length)
diff --git a/tempest/services/compute/xml/volumes_extensions_client.py b/tempest/services/compute/xml/volumes_extensions_client.py
index 69b9bac..06cfcfb 100644
--- a/tempest/services/compute/xml/volumes_extensions_client.py
+++ b/tempest/services/compute/xml/volumes_extensions_client.py
@@ -81,10 +81,10 @@
volumes += [self._parse_volume(vol) for vol in list(body)]
return resp, volumes
- def get_volume(self, volume_id, wait=None):
+ def get_volume(self, volume_id):
"""Returns the details of a single volume."""
url = "os-volumes/%s" % str(volume_id)
- resp, body = self.get(url, self.headers, wait=wait)
+ resp, body = self.get(url, self.headers)
body = etree.fromstring(body)
return resp, self._parse_volume(body)
diff --git a/tempest/services/image/json/__init__.py b/tempest/services/image/v1/__init__.py
similarity index 100%
copy from tempest/services/image/json/__init__.py
copy to tempest/services/image/v1/__init__.py
diff --git a/tempest/services/image/json/__init__.py b/tempest/services/image/v1/json/__init__.py
similarity index 100%
rename from tempest/services/image/json/__init__.py
rename to tempest/services/image/v1/json/__init__.py
diff --git a/tempest/services/image/json/image_client.py b/tempest/services/image/v1/json/image_client.py
similarity index 77%
rename from tempest/services/image/json/image_client.py
rename to tempest/services/image/v1/json/image_client.py
index e9276aa..45e93e2 100644
--- a/tempest/services/image/json/image_client.py
+++ b/tempest/services/image/v1/json/image_client.py
@@ -19,13 +19,11 @@
import errno
import json
import os
-import time
import urllib
from tempest.common import glance_http
from tempest.common.rest_client import RestClient
from tempest import exceptions
-from tempest import manager
class ImageClientJSON(RestClient):
@@ -97,11 +95,11 @@
return None
def _get_http(self):
- temp_manager = manager.DefaultClientManager()
- keystone = temp_manager._get_identity_client()
- token = keystone.auth_token
- endpoint = keystone.service_catalog.url_for(service_type='image',
- endpoint_type='publicURL')
+ token, endpoint = self.keystone_auth(self.user,
+ self.password,
+ self.auth_url,
+ self.service,
+ self.tenant_name)
dscv = self.config.identity.disable_ssl_certificate_validation
return glance_http.HTTPClient(endpoint=endpoint, token=token,
insecure=dscv)
@@ -170,31 +168,69 @@
def delete_image(self, image_id):
url = 'v1/images/%s' % image_id
- try:
- self.delete(url)
- except exceptions.Unauthorized:
- url = '/' + url
- self.http.raw_request('DELETE', url)
+ self.delete(url)
- def image_list(self, params=None):
+ def image_list(self, **kwargs):
url = 'v1/images'
- if params:
- url += '?%s' % urllib.urlencode(params)
+ if len(kwargs) > 0:
+ url += '?%s' % urllib.urlencode(kwargs)
resp, body = self.get(url)
body = json.loads(body)
return resp, body['images']
- def get_image(self, image_id, wait=None):
+ def image_list_detail(self, **kwargs):
+ url = 'v1/images/detail'
+
+ if len(kwargs) > 0:
+ url += '?%s' % urllib.urlencode(kwargs)
+
+ resp, body = self.get(url)
+ body = json.loads(body)
+ return resp, body['images']
+
+ def get_image(self, image_id):
url = 'v1/images/%s' % image_id
- resp, __ = self.get(url, wait=wait)
+ resp, __ = self.get(url)
body = self._image_meta_from_headers(resp)
return resp, body
def is_resource_deleted(self, id):
try:
- self.get_image(id, wait=True)
+ self.get_image(id)
except exceptions.NotFound:
return True
return False
+
+ def get_image_membership(self, image_id):
+ url = 'v1/images/%s/members' % image_id
+ resp, body = self.get(url)
+ body = json.loads(body)
+ return resp, body
+
+ def get_shared_images(self, member_id):
+ url = 'v1/shared-images/%s' % member_id
+ resp, body = self.get(url)
+ body = json.loads(body)
+ return resp, body
+
+ def add_member(self, member_id, image_id, can_share=False):
+ url = 'v1/images/%s/members/%s' % (image_id, member_id)
+ body = None
+ if can_share:
+ body = json.dumps({'member': {'can_share': True}})
+ resp, __ = self.put(url, body, self.headers)
+ return resp
+
+ def delete_member(self, member_id, image_id):
+ url = 'v1/images/%s/members/%s' % (image_id, member_id)
+ resp, __ = self.delete(url)
+ return resp
+
+ def replace_membership_list(self, image_id, member_list):
+ url = 'v1/images/%s/members' % image_id
+ body = json.dumps({'membership': member_list})
+ resp, data = self.put(url, body, self.headers)
+ data = json.loads(data)
+ return resp, data
diff --git a/tempest/services/image/json/__init__.py b/tempest/services/image/v2/__init__.py
similarity index 100%
copy from tempest/services/image/json/__init__.py
copy to tempest/services/image/v2/__init__.py
diff --git a/tempest/services/image/json/__init__.py b/tempest/services/image/v2/json/__init__.py
similarity index 100%
copy from tempest/services/image/json/__init__.py
copy to tempest/services/image/v2/json/__init__.py
diff --git a/tempest/services/image/v2/json/image_client.py b/tempest/services/image/v2/json/image_client.py
new file mode 100644
index 0000000..bcae79b
--- /dev/null
+++ b/tempest/services/image/v2/json/image_client.py
@@ -0,0 +1,123 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2013 IBM
+# 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 json
+import urllib
+
+import jsonschema
+
+from tempest.common import glance_http
+from tempest.common import rest_client
+from tempest import exceptions
+
+
+class ImageClientV2JSON(rest_client.RestClient):
+
+ def __init__(self, config, username, password, auth_url, tenant_name=None):
+ super(ImageClientV2JSON, self).__init__(config, username, password,
+ auth_url, tenant_name)
+ self.service = self.config.images.catalog_type
+ self.http = self._get_http()
+
+ def _get_http(self):
+ token, endpoint = self.keystone_auth(self.user, self.password,
+ self.auth_url, self.service,
+ self.tenant_name)
+ dscv = self.config.identity.disable_ssl_certificate_validation
+ return glance_http.HTTPClient(endpoint=endpoint, token=token,
+ insecure=dscv)
+
+ def get_images_schema(self):
+ url = 'v2/schemas/images'
+ resp, body = self.get(url)
+ body = json.loads(body)
+ return resp, body
+
+ def get_image_schema(self):
+ url = 'v2/schemas/image'
+ resp, body = self.get(url)
+ body = json.loads(body)
+ return resp, body
+
+ def _validate_schema(self, body, type='image'):
+ if type == 'image':
+ resp, schema = self.get_image_schema()
+ elif type == 'images':
+ resp, schema = self.get_images_schema()
+ else:
+ raise ValueError("%s is not a valid schema type" % type)
+
+ jsonschema.validate(body, schema)
+
+ def create_image(self, name, container_format, disk_format, is_public=True,
+ properties=None):
+ params = {
+ "name": name,
+ "container_format": container_format,
+ "disk_format": disk_format,
+ }
+ if is_public:
+ params["visibility"] = "public"
+ else:
+ params["visibility"] = "private"
+
+ data = json.dumps(params)
+ self._validate_schema(data)
+
+ resp, body = self.post('v2/images', data, self.headers)
+ body = json.loads(body)
+ return resp, body
+
+ def delete_image(self, image_id):
+ url = 'v2/images/%s' % image_id
+ self.delete(url)
+
+ def image_list(self, params=None):
+ url = 'v2/images'
+
+ if params:
+ url += '?%s' % urllib.urlencode(params)
+
+ resp, body = self.get(url)
+ body = json.loads(body)
+ self._validate_schema(body, type='images')
+ return resp, body['images']
+
+ def get_image_metadata(self, image_id):
+ url = 'v2/images/%s' % image_id
+ resp, body = self.get(url)
+ body = json.loads(body)
+ return resp, body
+
+ def is_resource_deleted(self, id):
+ try:
+ self.get_image_metadata(id)
+ except exceptions.NotFound:
+ return True
+ return False
+
+ def store_image(self, image_id, data):
+ url = 'v2/images/%s/file' % image_id
+ headers = {'Content-Type': 'application/octet-stream'}
+ resp, body = self.http.raw_request('PUT', url, headers=headers,
+ body=data)
+ return resp, body
+
+ def get_image_file(self, image_id):
+ url = 'v2/images/%s/file' % image_id
+ resp, body = self.get(url)
+ return resp, body
diff --git a/tempest/services/object_storage/account_client.py b/tempest/services/object_storage/account_client.py
index fec273c..a71a287 100644
--- a/tempest/services/object_storage/account_client.py
+++ b/tempest/services/object_storage/account_client.py
@@ -103,7 +103,7 @@
self.service = self.config.object_storage.catalog_type
self.format = 'json'
- def request(self, method, url, headers=None, body=None, wait=None):
+ def request(self, method, url, headers=None, body=None):
"""A simple HTTP request interface."""
self.http_obj = httplib2.Http()
if headers is None:
diff --git a/tempest/services/object_storage/container_client.py b/tempest/services/object_storage/container_client.py
index 7b5efff..93477fa 100644
--- a/tempest/services/object_storage/container_client.py
+++ b/tempest/services/object_storage/container_client.py
@@ -97,7 +97,6 @@
#TODO(dwalleck): Rewite using json format to avoid newlines at end of
#obj names. Set limit to API limit - 1 (max returned items = 9999)
limit = 9999
- marker = None
if params is not None:
if 'limit' in params:
limit = params['limit']
diff --git a/tempest/services/object_storage/object_client.py b/tempest/services/object_storage/object_client.py
index ac1859a..9626b6b 100644
--- a/tempest/services/object_storage/object_client.py
+++ b/tempest/services/object_storage/object_client.py
@@ -156,7 +156,7 @@
self.service = self.config.object_storage.catalog_type
self.format = 'json'
- def request(self, method, url, headers=None, body=None, wait=None):
+ def request(self, method, url, headers=None, body=None):
"""A simple HTTP request interface."""
dscv = self.config.identity.disable_ssl_certificate_validation
self.http_obj = httplib2.Http(disable_ssl_certificate_validation=dscv)
diff --git a/tempest/services/volume/json/volumes_client.py b/tempest/services/volume/json/volumes_client.py
index ff1556f..6b0befd 100644
--- a/tempest/services/volume/json/volumes_client.py
+++ b/tempest/services/volume/json/volumes_client.py
@@ -56,10 +56,10 @@
body = json.loads(body)
return resp, body['volumes']
- def get_volume(self, volume_id, wait=None):
+ def get_volume(self, volume_id):
"""Returns the details of a single volume."""
url = "volumes/%s" % str(volume_id)
- resp, body = self.get(url, wait=wait)
+ resp, body = self.get(url)
body = json.loads(body)
return resp, body['volume']
diff --git a/tempest/services/volume/xml/volumes_client.py b/tempest/services/volume/xml/volumes_client.py
index 5041869..4c15256 100644
--- a/tempest/services/volume/xml/volumes_client.py
+++ b/tempest/services/volume/xml/volumes_client.py
@@ -84,10 +84,10 @@
volumes += [self._parse_volume(vol) for vol in list(body)]
return resp, volumes
- def get_volume(self, volume_id, wait=None):
+ def get_volume(self, volume_id):
"""Returns the details of a single volume."""
url = "volumes/%s" % str(volume_id)
- resp, body = self.get(url, self.headers, wait=wait)
+ resp, body = self.get(url, self.headers)
body = etree.fromstring(body)
return resp, self._parse_volume(body)
diff --git a/tempest/test.py b/tempest/test.py
index 90793ac..e0639b6 100644
--- a/tempest/test.py
+++ b/tempest/test.py
@@ -58,12 +58,11 @@
class TestCase(BaseTestCase):
-
- """
- Base test case class for all Tempest tests
+ """Base test case class for all Tempest tests
Contains basic setup and convenience methods
"""
+
manager_class = None
@classmethod
diff --git a/tempest/testboto.py b/tempest/testboto.py
index 5625841..cee8843 100644
--- a/tempest/testboto.py
+++ b/tempest/testboto.py
@@ -17,16 +17,21 @@
from contextlib import closing
import logging
+import os
import re
+import urlparse
import boto
from boto import ec2
from boto import exception
from boto import s3
+import keystoneclient.exceptions
+import tempest.clients
+from tempest.common.utils.file_utils import have_effective_read_access
+import tempest.config
from tempest import exceptions
import tempest.test
-import tempest.tests.boto
from tempest.tests.boto.utils.wait import re_search_wait
from tempest.tests.boto.utils.wait import state_wait
from tempest.tests.boto.utils.wait import wait_exception
@@ -34,6 +39,71 @@
LOG = logging.getLogger(__name__)
+def decision_maker():
+ A_I_IMAGES_READY = True # ari,ami,aki
+ S3_CAN_CONNECT_ERROR = None
+ EC2_CAN_CONNECT_ERROR = None
+ secret_matcher = re.compile("[A-Za-z0-9+/]{32,}") # 40 in other system
+ id_matcher = re.compile("[A-Za-z0-9]{20,}")
+
+ def all_read(*args):
+ return all(map(have_effective_read_access, args))
+
+ config = tempest.config.TempestConfig()
+ materials_path = config.boto.s3_materials_path
+ ami_path = materials_path + os.sep + config.boto.ami_manifest
+ aki_path = materials_path + os.sep + config.boto.aki_manifest
+ ari_path = materials_path + os.sep + config.boto.ari_manifest
+
+ A_I_IMAGES_READY = all_read(ami_path, aki_path, ari_path)
+ boto_logger = logging.getLogger('boto')
+ level = boto_logger.level
+ boto_logger.setLevel(logging.CRITICAL) # suppress logging for these
+
+ def _cred_sub_check(connection_data):
+ if not id_matcher.match(connection_data["aws_access_key_id"]):
+ raise Exception("Invalid AWS access Key")
+ if not secret_matcher.match(connection_data["aws_secret_access_key"]):
+ raise Exception("Invalid AWS secret Key")
+ raise Exception("Unknown (Authentication?) Error")
+ openstack = tempest.clients.Manager()
+ try:
+ if urlparse.urlparse(config.boto.ec2_url).hostname is None:
+ raise Exception("Failed to get hostname from the ec2_url")
+ ec2client = openstack.ec2api_client
+ try:
+ ec2client.get_all_regions()
+ except exception.BotoServerError as exc:
+ if exc.error_code is None:
+ raise Exception("EC2 target does not looks EC2 service")
+ _cred_sub_check(ec2client.connection_data)
+
+ except keystoneclient.exceptions.Unauthorized:
+ EC2_CAN_CONNECT_ERROR = "AWS credentials not set," +\
+ " faild to get them even by keystoneclient"
+ except Exception as exc:
+ EC2_CAN_CONNECT_ERROR = str(exc)
+
+ try:
+ if urlparse.urlparse(config.boto.s3_url).hostname is None:
+ raise Exception("Failed to get hostname from the s3_url")
+ s3client = openstack.s3_client
+ try:
+ s3client.get_bucket("^INVALID*#()@INVALID.")
+ except exception.BotoServerError as exc:
+ if exc.status == 403:
+ _cred_sub_check(s3client.connection_data)
+ except Exception as exc:
+ S3_CAN_CONNECT_ERROR = str(exc)
+ except keystoneclient.exceptions.Unauthorized:
+ S3_CAN_CONNECT_ERROR = "AWS credentials not set," +\
+ " faild to get them even by keystoneclient"
+ boto_logger.setLevel(level)
+ return {'A_I_IMAGES_READY': A_I_IMAGES_READY,
+ 'S3_CAN_CONNECT_ERROR': S3_CAN_CONNECT_ERROR,
+ 'EC2_CAN_CONNECT_ERROR': EC2_CAN_CONNECT_ERROR}
+
+
class BotoExceptionMatcher(object):
STATUS_RE = r'[45]\d\d'
CODE_RE = '.*' # regexp makes sense in group match
@@ -121,7 +191,7 @@
class BotoTestCase(tempest.test.BaseTestCase):
"""Recommended to use as base class for boto related test."""
- conclusion = tempest.tests.boto.generic_setup_package()
+ conclusion = decision_maker()
@classmethod
def setUpClass(cls):
@@ -130,13 +200,13 @@
cls._resource_trash_bin = {}
cls._sequence = -1
if (hasattr(cls, "EC2") and
- tempest.tests.boto.EC2_CAN_CONNECT_ERROR is not None):
+ cls.conclusion['EC2_CAN_CONNECT_ERROR'] is not None):
raise cls.skipException("EC2 " + cls.__name__ + ": " +
- tempest.tests.boto.EC2_CAN_CONNECT_ERROR)
+ cls.conclusion['EC2_CAN_CONNECT_ERROR'])
if (hasattr(cls, "S3") and
- tempest.tests.boto.S3_CAN_CONNECT_ERROR is not None):
+ cls.conclusion['S3_CAN_CONNECT_ERROR'] is not None):
raise cls.skipException("S3 " + cls.__name__ + ": " +
- tempest.tests.boto.S3_CAN_CONNECT_ERROR)
+ cls.conclusion['S3_CAN_CONNECT_ERROR'])
@classmethod
def addResourceCleanUp(cls, function, *args, **kwargs):
diff --git a/tempest/tests/boto/__init__.py b/tempest/tests/boto/__init__.py
index dd224d6..e69de29 100644
--- a/tempest/tests/boto/__init__.py
+++ b/tempest/tests/boto/__init__.py
@@ -1,94 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2012 OpenStack, LLC
-# 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 os
-import re
-import urlparse
-
-import boto.exception
-import keystoneclient.exceptions
-
-import tempest.clients
-from tempest.common.utils.file_utils import have_effective_read_access
-import tempest.config
-
-A_I_IMAGES_READY = True # ari,ami,aki
-S3_CAN_CONNECT_ERROR = None
-EC2_CAN_CONNECT_ERROR = None
-
-
-def generic_setup_package():
- global A_I_IMAGES_READY
- global S3_CAN_CONNECT_ERROR
- global EC2_CAN_CONNECT_ERROR
- secret_matcher = re.compile("[A-Za-z0-9+/]{32,}") # 40 in other system
- id_matcher = re.compile("[A-Za-z0-9]{20,}")
-
- def all_read(*args):
- return all(map(have_effective_read_access, args))
-
- config = tempest.config.TempestConfig()
- materials_path = config.boto.s3_materials_path
- ami_path = materials_path + os.sep + config.boto.ami_manifest
- aki_path = materials_path + os.sep + config.boto.aki_manifest
- ari_path = materials_path + os.sep + config.boto.ari_manifest
-
- A_I_IMAGES_READY = all_read(ami_path, aki_path, ari_path)
- boto_logger = logging.getLogger('boto')
- level = boto_logger.level
- boto_logger.setLevel(logging.CRITICAL) # suppress logging for these
-
- def _cred_sub_check(connection_data):
- if not id_matcher.match(connection_data["aws_access_key_id"]):
- raise Exception("Invalid AWS access Key")
- if not secret_matcher.match(connection_data["aws_secret_access_key"]):
- raise Exception("Invalid AWS secret Key")
- raise Exception("Unknown (Authentication?) Error")
- openstack = tempest.clients.Manager()
- try:
- if urlparse.urlparse(config.boto.ec2_url).hostname is None:
- raise Exception("Failed to get hostname from the ec2_url")
- ec2client = openstack.ec2api_client
- try:
- ec2client.get_all_regions()
- except boto.exception.BotoServerError as exc:
- if exc.error_code is None:
- raise Exception("EC2 target does not looks EC2 service")
- _cred_sub_check(ec2client.connection_data)
-
- except keystoneclient.exceptions.Unauthorized:
- EC2_CAN_CONNECT_ERROR = "AWS credentials not set," +\
- " faild to get them even by keystoneclient"
- except Exception as exc:
- EC2_CAN_CONNECT_ERROR = str(exc)
-
- try:
- if urlparse.urlparse(config.boto.s3_url).hostname is None:
- raise Exception("Failed to get hostname from the s3_url")
- s3client = openstack.s3_client
- try:
- s3client.get_bucket("^INVALID*#()@INVALID.")
- except boto.exception.BotoServerError as exc:
- if exc.status == 403:
- _cred_sub_check(s3client.connection_data)
- except Exception as exc:
- S3_CAN_CONNECT_ERROR = str(exc)
- except keystoneclient.exceptions.Unauthorized:
- S3_CAN_CONNECT_ERROR = "AWS credentials not set," +\
- " faild to get them even by keystoneclient"
- boto_logger.setLevel(level)
diff --git a/tempest/tests/boto/test_ec2_instance_run.py b/tempest/tests/boto/test_ec2_instance_run.py
index 6b61c11..3293dea 100644
--- a/tempest/tests/boto/test_ec2_instance_run.py
+++ b/tempest/tests/boto/test_ec2_instance_run.py
@@ -17,15 +17,15 @@
import logging
-from boto.exception import EC2ResponseError
+from boto import exception
import testtools
from tempest import clients
from tempest.common.utils.data_utils import rand_name
from tempest.common.utils.linux.remote_client import RemoteClient
+from tempest import exceptions
from tempest.test import attr
from tempest.testboto import BotoTestCase
-import tempest.tests.boto
from tempest.tests.boto.utils.s3 import s3_upload_dir
from tempest.tests.boto.utils.wait import re_search_wait
from tempest.tests.boto.utils.wait import state_wait
@@ -39,7 +39,7 @@
@classmethod
def setUpClass(cls):
super(InstanceRunTest, cls).setUpClass()
- if not tempest.tests.boto.A_I_IMAGES_READY:
+ if not cls.conclusion['A_I_IMAGES_READY']:
raise cls.skipException("".join(("EC2 ", cls.__name__,
": requires ami/aki/ari manifest")))
cls.os = clients.Manager()
@@ -86,7 +86,8 @@
if state != "available":
for _image in cls.images.itervalues():
cls.ec2_client.deregister_image(_image["image_id"])
- raise EC2RegisterImageException(image_id=image["image_id"])
+ raise exceptions.EC2RegisterImageException(image_id=
+ image["image_id"])
@attr(type='smoke')
def test_run_stop_terminate_instance(self):
@@ -129,7 +130,7 @@
instance.update(validate=True)
except ValueError:
pass
- except EC2ResponseError as exc:
+ except exception.EC2ResponseError as exc:
if self.ec2_error_code.\
client.InvalidInstanceID.NotFound.match(exc):
pass
@@ -150,16 +151,18 @@
group_desc)
self.addResourceCleanUp(self.destroy_security_group_wait,
security_group)
- self.ec2_client.authorize_security_group(sec_group_name,
- ip_protocol="icmp",
- cidr_ip="0.0.0.0/0",
- from_port=-1,
- to_port=-1)
- self.ec2_client.authorize_security_group(sec_group_name,
- ip_protocol="tcp",
- cidr_ip="0.0.0.0/0",
- from_port=22,
- to_port=22)
+ self.assertTrue(self.ec2_client.authorize_security_group(
+ sec_group_name,
+ ip_protocol="icmp",
+ cidr_ip="0.0.0.0/0",
+ from_port=-1,
+ to_port=-1))
+ self.assertTrue(self.ec2_client.authorize_security_group(
+ sec_group_name,
+ ip_protocol="tcp",
+ cidr_ip="0.0.0.0/0",
+ from_port=22,
+ to_port=22))
reservation = image_ami.run(kernel_id=self.images["aki"]["image_id"],
ramdisk_id=self.images["ari"]["image_id"],
instance_type=self.instance_type,
@@ -176,7 +179,7 @@
address = self.ec2_client.allocate_address()
rcuk_a = self.addResourceCleanUp(address.delete)
- address.associate(instance.id)
+ self.assertTrue(address.associate(instance.id))
rcuk_da = self.addResourceCleanUp(address.disassociate)
#TODO(afazekas): ping test. dependecy/permission ?
diff --git a/tempest/tests/boto/test_s3_ec2_images.py b/tempest/tests/boto/test_s3_ec2_images.py
index 1088b00..4068aba 100644
--- a/tempest/tests/boto/test_s3_ec2_images.py
+++ b/tempest/tests/boto/test_s3_ec2_images.py
@@ -23,7 +23,6 @@
from tempest.common.utils.data_utils import rand_name
from tempest.test import attr
from tempest.testboto import BotoTestCase
-import tempest.tests.boto
from tempest.tests.boto.utils.s3 import s3_upload_dir
from tempest.tests.boto.utils.wait import state_wait
@@ -34,7 +33,7 @@
@classmethod
def setUpClass(cls):
super(S3ImagesTest, cls).setUpClass()
- if not tempest.tests.boto.A_I_IMAGES_READY:
+ if not cls.conclusion['A_I_IMAGES_READY']:
raise cls.skipException("".join(("EC2 ", cls.__name__,
": requires ami/aki/ari manifest")))
cls.os = clients.Manager()
diff --git a/tempest/tests/compute/admin/test_quotas.py b/tempest/tests/compute/admin/test_quotas.py
index d63f72f..7430a7c 100644
--- a/tempest/tests/compute/admin/test_quotas.py
+++ b/tempest/tests/compute/admin/test_quotas.py
@@ -152,6 +152,19 @@
#TODO(afazekas): Add test that tried to update the quota_set as a regular user
+ @attr(type='negative')
+ def test_create_server_when_instances_quota_is_full(self):
+ #Once instances quota limit is reached, disallow server creation
+ resp, quota_set = self.client.get_quota_set(self.demo_tenant_id)
+ default_instances_quota = quota_set['instances']
+ instances_quota = 0 # Set quota to zero to disallow server creation
+
+ self.adm_client.update_quota_set(self.demo_tenant_id,
+ instances=instances_quota)
+ self.addCleanup(self.adm_client.update_quota_set, self.demo_tenant_id,
+ instances=default_instances_quota)
+ self.assertRaises(exceptions.OverLimit, self.create_server)
+
class QuotasAdminTestXML(QuotasAdminTestJSON):
_interface = 'xml'
diff --git a/tempest/tests/compute/base.py b/tempest/tests/compute/base.py
index 94fff13..3b2026e 100644
--- a/tempest/tests/compute/base.py
+++ b/tempest/tests/compute/base.py
@@ -59,6 +59,7 @@
cls.limits_client = os.limits_client
cls.volumes_extensions_client = os.volumes_extensions_client
cls.volumes_client = os.volumes_client
+ cls.interfaces_client = os.interfaces_client
cls.build_interval = cls.config.compute.build_interval
cls.build_timeout = cls.config.compute.build_timeout
cls.ssh_user = cls.config.compute.ssh_user
diff --git a/tempest/tests/compute/floating_ips/test_floating_ips_actions.py b/tempest/tests/compute/floating_ips/test_floating_ips_actions.py
index 0f63016..0ff81e1 100644
--- a/tempest/tests/compute/floating_ips/test_floating_ips_actions.py
+++ b/tempest/tests/compute/floating_ips/test_floating_ips_actions.py
@@ -114,42 +114,26 @@
# Negative test:Deletion of a nonexistent floating IP
# from project should fail
- #Deleting the non existent floating IP
- try:
- resp, body = self.client.delete_floating_ip(self.non_exist_id)
- except Exception:
- pass
- else:
- self.fail('Should not be able to delete a nonexistent floating IP')
+ # Deleting the non existent floating IP
+ self.assertRaises(exceptions.NotFound, self.client.delete_floating_ip,
+ self.non_exist_id)
@attr(type='negative')
def test_associate_nonexistant_floating_ip(self):
# Negative test:Association of a non existent floating IP
# to specific server should fail
- #Associating non existent floating IP
- try:
- resp, body = \
- self.client.associate_floating_ip_to_server("0.0.0.0",
- self.server_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to associate'
- ' a nonexistent floating IP')
+ # Associating non existent floating IP
+ self.assertRaises(exceptions.NotFound,
+ self.client.associate_floating_ip_to_server,
+ "0.0.0.0", self.server_id)
@attr(type='negative')
def test_dissociate_nonexistant_floating_ip(self):
# Negative test:Dissociation of a non existent floating IP should fail
- #Dissociating non existent floating IP
- try:
- resp, body = \
- self.client.disassociate_floating_ip_from_server("0.0.0.0",
- self.server_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to dissociate'
- ' a nonexistent floating IP')
+ # Dissociating non existent floating IP
+ self.assertRaises(exceptions.NotFound,
+ self.client.disassociate_floating_ip_from_server,
+ "0.0.0.0", self.server_id)
@attr(type='positive')
def test_associate_already_associated_floating_ip(self):
@@ -171,38 +155,25 @@
self.client.associate_floating_ip_to_server(self.floating_ip,
self.new_server_id)
- #Make sure no longer associated with old server
- try:
- self.client.disassociate_floating_ip_from_server(
- self.floating_ip,
- self.server_id)
- except (exceptions.NotFound, exceptions.BadRequest):
- pass
- else:
- self.fail('The floating IP should be associated to the second '
- 'server')
+ self.addCleanup(self.servers_client.delete_server, self.new_server_id)
if (resp['status'] is not None):
- #Dissociation of the floating IP associated in this method
- resp, _ = \
- self.client.disassociate_floating_ip_from_server(
- self.floating_ip,
- self.new_server_id)
- #Deletion of server created in this method
- resp, body = self.servers_client.delete_server(self.new_server_id)
+ self.addCleanup(self.client.disassociate_floating_ip_from_server,
+ self.floating_ip,
+ self.new_server_id)
+
+ # Make sure no longer associated with old server
+ self.assertRaises((exceptions.NotFound,
+ exceptions.UnprocessableEntity),
+ self.client.disassociate_floating_ip_from_server,
+ self.floating_ip, self.server_id)
@attr(type='negative')
def test_associate_ip_to_server_without_passing_floating_ip(self):
# Negative test:Association of empty floating IP to specific server
# should raise NotFound exception
- try:
- resp, body =\
- self.client.associate_floating_ip_to_server('',
- self.server_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Association of floating IP to specific server'
- ' with out passing floating IP should raise BadRequest')
+ self.assertRaises(exceptions.NotFound,
+ self.client.associate_floating_ip_to_server,
+ '', self.server_id)
class FloatingIPsTestXML(FloatingIPsTestJSON):
diff --git a/tempest/tests/compute/floating_ips/test_list_floating_ips.py b/tempest/tests/compute/floating_ips/test_list_floating_ips.py
index 11b9465..b795909 100644
--- a/tempest/tests/compute/floating_ips/test_list_floating_ips.py
+++ b/tempest/tests/compute/floating_ips/test_list_floating_ips.py
@@ -90,14 +90,8 @@
non_exist_id = rand_name('999')
if non_exist_id not in floating_ip_id:
break
- try:
- resp, body = \
- self.client.get_floating_ip_details(non_exist_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to GET the details from a'
- 'nonexistant floating IP')
+ self.assertRaises(exceptions.NotFound,
+ self.client.get_floating_ip_details, non_exist_id)
class FloatingIPDetailsTestXML(FloatingIPDetailsTestJSON):
diff --git a/tempest/tests/compute/images/test_image_metadata.py b/tempest/tests/compute/images/test_image_metadata.py
index fa69395..311ee8e 100644
--- a/tempest/tests/compute/images/test_image_metadata.py
+++ b/tempest/tests/compute/images/test_image_metadata.py
@@ -111,68 +111,41 @@
def test_list_nonexistant_image_metadata(self):
# Negative test: List on nonexistant image
# metadata should not happen
- try:
- resp, resp_metadata = self.client.list_image_metadata(999)
- except exceptions.NotFound:
- pass
- else:
- self.fail('List on nonexistant image metadata should'
- 'not happen')
+ self.assertRaises(exceptions.NotFound, self.client.list_image_metadata,
+ 999)
@attr(type='negative')
def test_update_nonexistant_image_metadata(self):
# Negative test:An update should not happen for a nonexistant image
meta = {'key1': 'alt1', 'key2': 'alt2'}
- try:
- resp, metadata = self.client.update_image_metadata(999, meta)
- except exceptions.NotFound:
- pass
- else:
- self.fail('An update shouldnt happen for nonexistant image')
+ self.assertRaises(exceptions.NotFound,
+ self.client.update_image_metadata, 999, meta)
@attr(type='negative')
def test_get_nonexistant_image_metadata_item(self):
# Negative test: Get on nonexistant image should not happen
- try:
- resp, metadata = self.client.get_image_metadata_item(999, 'key2')
- except exceptions.NotFound:
- pass
- else:
- self.fail('Get on nonexistant image should not happen')
+ self.assertRaises(exceptions.NotFound,
+ self.client.get_image_metadata_item, 999, 'key2')
@attr(type='negative')
def test_set_nonexistant_image_metadata(self):
# Negative test: Metadata should not be set to a nonexistant image
meta = {'key1': 'alt1', 'key2': 'alt2'}
- try:
- resp, meta = self.client.set_image_metadata(999, meta)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Metadata should not be set to a nonexistant image')
+ self.assertRaises(exceptions.NotFound, self.client.set_image_metadata,
+ 999, meta)
@attr(type='negative')
def test_set_nonexistant_image_metadata_item(self):
# Negative test: Metadata item should not be set to a
# nonexistant image
meta = {'key1': 'alt'}
- try:
- resp, body = self.client.set_image_metadata_item(999, 'key1', meta)
- resp, metadata = self.client.list_image_metadata(999)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Metadata item should not be set to a nonexistant image')
+ self.assertRaises(exceptions.NotFound,
+ self.client.set_image_metadata_item, 999, 'key1',
+ meta)
@attr(type='negative')
def test_delete_nonexistant_image_metadata_item(self):
# Negative test: Shouldnt be able to delete metadata
- # item from nonexistant image
- try:
- resp, body = self.client.delete_image_metadata_item(999, 'key1')
- resp, metadata = self.client.list_image_metadata(999)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to delete metadata item from a'
- 'nonexistant image')
+ # item from nonexistant image
+ self.assertRaises(exceptions.NotFound,
+ self.client.delete_image_metadata_item, 999, 'key1')
diff --git a/tempest/tests/compute/images/test_images.py b/tempest/tests/compute/images/test_images.py
index 1e90202..a61cef6 100644
--- a/tempest/tests/compute/images/test_images.py
+++ b/tempest/tests/compute/images/test_images.py
@@ -133,40 +133,24 @@
@attr(type='negative')
def test_create_image_specify_uuid_35_characters_or_less(self):
# Return an error if Image ID passed is 35 characters or less
- try:
- snapshot_name = rand_name('test-snap-')
- test_uuid = ('a' * 35)
- self.assertRaises(exceptions.NotFound, self.client.create_image,
- test_uuid, snapshot_name)
- except Exception:
- self.fail("Should return 404 Not Found if server uuid is 35"
- " characters or less")
+ snapshot_name = rand_name('test-snap-')
+ test_uuid = ('a' * 35)
+ self.assertRaises(exceptions.NotFound, self.client.create_image,
+ test_uuid, snapshot_name)
@attr(type='negative')
def test_create_image_specify_uuid_37_characters_or_more(self):
# Return an error if Image ID passed is 37 characters or more
- try:
- snapshot_name = rand_name('test-snap-')
- test_uuid = ('a' * 37)
- self.assertRaises(exceptions.NotFound, self.client.create_image,
- test_uuid, snapshot_name)
- except Exception:
- self.fail("Should return 404 Not Found if server uuid is 37"
- " characters or more")
+ snapshot_name = rand_name('test-snap-')
+ test_uuid = ('a' * 37)
+ self.assertRaises(exceptions.NotFound, self.client.create_image,
+ test_uuid, snapshot_name)
@attr(type='negative')
def test_delete_image_with_invalid_image_id(self):
# An image should not be deleted with invalid image id
- try:
- # Delete an image with invalid image id
- resp, _ = self.client.delete_image('!@$%^&*()')
-
- except exceptions.NotFound:
- pass
-
- else:
- self.fail("DELETE image request should rasie NotFound exception "
- "when requested with invalid image")
+ self.assertRaises(exceptions.NotFound, self.client.delete_image,
+ '!@$%^&*()')
@attr(type='negative')
def test_delete_non_existent_image(self):
@@ -179,44 +163,25 @@
@attr(type='negative')
def test_delete_image_blank_id(self):
# Return an error while trying to delete an image with blank Id
-
- try:
- self.assertRaises(exceptions.NotFound, self.client.delete_image,
- '')
- except Exception:
- self.fail("Did not return HTTP 404 NotFound for blank image id")
+ self.assertRaises(exceptions.NotFound, self.client.delete_image, '')
@attr(type='negative')
def test_delete_image_non_hex_string_id(self):
# Return an error while trying to delete an image with non hex id
-
image_id = '11a22b9-120q-5555-cc11-00ab112223gj'
- try:
- self.assertRaises(exceptions.NotFound, self.client.delete_image,
- image_id)
- except Exception:
- self.fail("Did not return HTTP 404 NotFound for non hex image")
+ self.assertRaises(exceptions.NotFound, self.client.delete_image,
+ image_id)
@attr(type='negative')
def test_delete_image_negative_image_id(self):
# Return an error while trying to delete an image with negative id
-
- try:
- self.assertRaises(exceptions.NotFound, self.client.delete_image,
- -1)
- except Exception:
- self.fail("Did not return HTTP 404 NotFound for negative image id")
+ self.assertRaises(exceptions.NotFound, self.client.delete_image, -1)
@attr(type='negative')
def test_delete_image_id_is_over_35_character_limit(self):
# Return an error while trying to delete image with id over limit
-
- try:
- self.assertRaises(exceptions.NotFound, self.client.delete_image,
- '11a22b9-120q-5555-cc11-00ab112223gj-3fac')
- except Exception:
- self.fail("Did not return HTTP 404 NotFound for image id that "
- "exceeds 35 character ID length limit")
+ self.assertRaises(exceptions.NotFound, self.client.delete_image,
+ '11a22b9-120q-5555-cc11-00ab112223gj-3fac')
class ImagesTestXML(ImagesTestJSON):
diff --git a/tempest/tests/compute/images/test_images_oneserver.py b/tempest/tests/compute/images/test_images_oneserver.py
index 6d3f043..d89b6dd 100644
--- a/tempest/tests/compute/images/test_images_oneserver.py
+++ b/tempest/tests/compute/images/test_images_oneserver.py
@@ -61,40 +61,28 @@
@testtools.skip("Until Bug 1006725 is fixed")
def test_create_image_specify_multibyte_character_image_name(self):
# Return an error if the image name has multi-byte characters
- try:
- snapshot_name = rand_name('\xef\xbb\xbf')
- self.assertRaises(exceptions.BadRequest,
- self.client.create_image, self.server['id'],
- snapshot_name)
- except Exception:
- self.fail("Should return 400 Bad Request if multi byte characters"
- " are used for image name")
+ snapshot_name = rand_name('\xef\xbb\xbf')
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_image, self.server['id'],
+ snapshot_name)
@attr(type='negative')
@testtools.skip("Until Bug 1005423 is fixed")
def test_create_image_specify_invalid_metadata(self):
# Return an error when creating image with invalid metadata
- try:
- snapshot_name = rand_name('test-snap-')
- meta = {'': ''}
- self.assertRaises(exceptions.BadRequest, self.client.create_image,
- self.server['id'], snapshot_name, meta)
-
- except Exception:
- self.fail("Should raise 400 Bad Request if meta data is invalid")
+ snapshot_name = rand_name('test-snap-')
+ meta = {'': ''}
+ self.assertRaises(exceptions.BadRequest, self.client.create_image,
+ self.server['id'], snapshot_name, meta)
@attr(type='negative')
@testtools.skip("Until Bug 1005423 is fixed")
def test_create_image_specify_metadata_over_limits(self):
# Return an error when creating image with meta data over 256 chars
- try:
- snapshot_name = rand_name('test-snap-')
- meta = {'a' * 260: 'b' * 260}
- self.assertRaises(exceptions.OverLimit, self.client.create_image,
- self.server['id'], snapshot_name, meta)
-
- except Exception:
- self.fail("Should raise 413 Over Limit if meta data was too long")
+ snapshot_name = rand_name('test-snap-')
+ meta = {'a' * 260: 'b' * 260}
+ self.assertRaises(exceptions.OverLimit, self.client.create_image,
+ self.server['id'], snapshot_name, meta)
@attr(type='negative')
@testtools.skipUnless(compute.MULTI_USER,
@@ -151,38 +139,28 @@
def test_create_second_image_when_first_image_is_being_saved(self):
# Disallow creating another image when first image is being saved
- try:
- # Create first snapshot
- snapshot_name = rand_name('test-snap-')
- resp, body = self.client.create_image(self.server['id'],
- snapshot_name)
- self.assertEqual(202, resp.status)
- image_id = parse_image_id(resp['location'])
- self.image_ids.append(image_id)
+ # Create first snapshot
+ snapshot_name = rand_name('test-snap-')
+ resp, body = self.client.create_image(self.server['id'],
+ snapshot_name)
+ self.assertEqual(202, resp.status)
+ image_id = parse_image_id(resp['location'])
+ self.image_ids.append(image_id)
- # Create second snapshot
- alt_snapshot_name = rand_name('test-snap-')
- self.client.create_image(self.server['id'],
- alt_snapshot_name)
- except exceptions.Duplicate:
- self.client.wait_for_image_status(image_id, 'ACTIVE')
-
- else:
- self.fail("Should not allow creating an image when another image "
- "of the server is still being saved")
+ # Create second snapshot
+ alt_snapshot_name = rand_name('test-snap-')
+ self.assertRaises(exceptions.Duplicate, self.client.create_image,
+ self.server['id'], alt_snapshot_name)
+ self.client.wait_for_image_status(image_id, 'ACTIVE')
@attr(type='negative')
@testtools.skip("Until Bug 1004564 is fixed")
def test_create_image_specify_name_over_256_chars(self):
# Return an error if snapshot name over 256 characters is passed
- try:
- snapshot_name = rand_name('a' * 260)
- self.assertRaises(exceptions.BadRequest, self.client.create_image,
- self.server['id'], snapshot_name)
- except Exception:
- self.fail("Should return 400 Bad Request if image name is over 256"
- " characters")
+ snapshot_name = rand_name('a' * 260)
+ self.assertRaises(exceptions.BadRequest, self.client.create_image,
+ self.server['id'], snapshot_name)
@attr(type='negative')
def test_delete_image_that_is_not_yet_active(self):
diff --git a/tempest/tests/compute/images/test_list_image_filters.py b/tempest/tests/compute/images/test_list_image_filters.py
index 5038a65..472f7fb 100644
--- a/tempest/tests/compute/images/test_list_image_filters.py
+++ b/tempest/tests/compute/images/test_list_image_filters.py
@@ -225,9 +225,4 @@
@attr(type='negative')
def test_get_nonexistant_image(self):
# Negative test: GET on non existant image should fail
- try:
- resp, image = self.client.get_image(999)
- except Exception:
- pass
- else:
- self.fail('GET on non existant image should fail')
+ self.assertRaises(exceptions.NotFound, self.client.get_image, 999)
diff --git a/tempest/tests/compute/keypairs/test_keypairs.py b/tempest/tests/compute/keypairs/test_keypairs.py
index aefc5ff..b48b439 100644
--- a/tempest/tests/compute/keypairs/test_keypairs.py
+++ b/tempest/tests/compute/keypairs/test_keypairs.py
@@ -134,48 +134,32 @@
# Keypair should not be created with a non RSA public key
k_name = rand_name('keypair-')
pub_key = "ssh-rsa JUNK nova@ubuntu"
- try:
- resp, _ = self.client.create_keypair(k_name, pub_key)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Expected BadRequest for invalid public key')
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_keypair, k_name, pub_key)
@attr(type='negative')
@testtools.skip("Skipped until the Bug #1086980 is resolved")
def test_keypair_delete_nonexistant_key(self):
# Non-existant key deletion should throw a proper error
k_name = rand_name("keypair-non-existant-")
- try:
- resp, _ = self.client.delete_keypair(k_name)
- except exceptions.NotFound:
- pass
- else:
- self.fail('nonexistent key')
+ self.assertRaises(exceptions.NotFound, self.client.delete_keypair,
+ k_name)
@attr(type='negative')
def test_create_keypair_with_empty_public_key(self):
# Keypair should not be created with an empty public key
k_name = rand_name("keypair-")
pub_key = ' '
- try:
- resp, _ = self.client.create_keypair(k_name, pub_key)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Expected BadRequest for empty public key')
+ self.assertRaises(exceptions.BadRequest, self.client.create_keypair,
+ k_name, pub_key)
@attr(type='negative')
def test_create_keypair_when_public_key_bits_exceeds_maximum(self):
# Keypair should not be created when public key bits are too long
k_name = rand_name("keypair-")
pub_key = 'ssh-rsa ' + 'A' * 2048 + ' openstack@ubuntu'
- try:
- resp, _ = self.client.create_keypair(k_name, pub_key)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Expected BadRequest for too long public key')
+ self.assertRaises(exceptions.BadRequest, self.client.create_keypair,
+ k_name, pub_key)
@attr(type='negative')
def test_create_keypair_with_duplicate_name(self):
@@ -184,47 +168,30 @@
resp, _ = self.client.create_keypair(k_name)
self.assertEqual(200, resp.status)
#Now try the same keyname to ceate another key
- try:
- resp, _ = self.client.create_keypair(k_name)
- #Expect a HTTP 409 Conflict Error
- except exceptions.Duplicate:
- pass
- else:
- self.fail('duplicate name')
+ self.assertRaises(exceptions.Duplicate, self.client.create_keypair,
+ k_name)
resp, _ = self.client.delete_keypair(k_name)
self.assertEqual(202, resp.status)
@attr(type='negative')
def test_create_keypair_with_empty_name_string(self):
# Keypairs with name being an empty string should not be created
- try:
- resp, _ = self.client.create_keypair('')
- except exceptions.BadRequest:
- pass
- else:
- self.fail('empty string')
+ self.assertRaises(exceptions.BadRequest, self.client.create_keypair,
+ '')
@attr(type='negative')
def test_create_keypair_with_long_keynames(self):
# Keypairs with name longer than 255 chars should not be created
k_name = 'keypair-'.ljust(260, '0')
- try:
- resp, _ = self.client.create_keypair(k_name)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('too long')
+ self.assertRaises(exceptions.BadRequest, self.client.create_keypair,
+ k_name)
@attr(type='negative')
def test_create_keypair_invalid_name(self):
# Keypairs with name being an invalid name should not be created
k_name = 'key_/.\@:'
- try:
- resp, _ = self.client.create_keypair(k_name)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('invalid name')
+ self.assertRaises(exceptions.BadRequest, self.client.create_keypair,
+ k_name)
class KeyPairsTestXML(KeyPairsTestJSON):
diff --git a/tempest/tests/compute/limits/test_absolute_limits.py b/tempest/tests/compute/limits/test_absolute_limits.py
index 129339c..2b31680 100644
--- a/tempest/tests/compute/limits/test_absolute_limits.py
+++ b/tempest/tests/compute/limits/test_absolute_limits.py
@@ -15,8 +15,6 @@
# License for the specific language governing permissions and limitations
# under the License.
-import testtools
-
from tempest.tests.compute import base
diff --git a/tempest/tests/compute/security_groups/test_security_group_rules.py b/tempest/tests/compute/security_groups/test_security_group_rules.py
index 5063fd3..dc85f4b 100644
--- a/tempest/tests/compute/security_groups/test_security_group_rules.py
+++ b/tempest/tests/compute/security_groups/test_security_group_rules.py
@@ -37,18 +37,19 @@
#Creating a Security Group to add rules to it
s_name = rand_name('securitygroup-')
s_description = rand_name('description-')
- resp, securitygroup =\
- self.client.create_security_group(s_name, s_description)
+ resp, securitygroup = \
+ self.client.create_security_group(s_name, s_description)
securitygroup_id = securitygroup['id']
#Adding rules to the created Security Group
parent_group_id = securitygroup['id']
ip_protocol = 'tcp'
from_port = 22
to_port = 22
- resp, rule =\
- self.client.create_security_group_rule(parent_group_id,
- ip_protocol, from_port,
- to_port)
+ resp, rule = \
+ self.client.create_security_group_rule(parent_group_id,
+ ip_protocol,
+ from_port,
+ to_port)
self.assertEqual(200, resp.status)
finally:
#Deleting the Security Group rule, created in this method
@@ -70,14 +71,14 @@
#Creating a Security Group to add rules to it
s_name = rand_name('securitygroup-')
s_description = rand_name('description-')
- resp, securitygroup =\
- self.client.create_security_group(s_name, s_description)
+ resp, securitygroup = \
+ self.client.create_security_group(s_name, s_description)
secgroup1 = securitygroup['id']
#Creating a Security Group so as to assign group_id to the rule
s_name2 = rand_name('securitygroup-')
s_description2 = rand_name('description-')
- resp, securitygroup =\
- self.client.create_security_group(s_name2, s_description2)
+ resp, securitygroup = \
+ self.client.create_security_group(s_name2, s_description2)
secgroup2 = securitygroup['id']
#Adding rules to the created Security Group with optional arguments
parent_group_id = secgroup1
@@ -86,12 +87,13 @@
to_port = 22
cidr = '10.2.3.124/24'
group_id = secgroup2
- resp, rule =\
- self.client.create_security_group_rule(parent_group_id,
- ip_protocol,
- from_port, to_port,
- cidr=cidr,
- group_id=group_id)
+ resp, rule = \
+ self.client.create_security_group_rule(parent_group_id,
+ ip_protocol,
+ from_port,
+ to_port,
+ cidr=cidr,
+ group_id=group_id)
rule_id = rule['id']
self.assertEqual(200, resp.status)
finally:
@@ -112,18 +114,19 @@
#Creating a Security Group to add rule to it
s_name = rand_name('securitygroup-')
s_description = rand_name('description-')
- resp, securitygroup =\
- self.client.create_security_group(s_name, s_description)
+ resp, securitygroup = \
+ self.client.create_security_group(s_name, s_description)
securitygroup_id = securitygroup['id']
#Adding rules to the created Security Group
parent_group_id = securitygroup['id']
ip_protocol = 'tcp'
from_port = 22
to_port = 22
- resp, rule =\
- self.client.create_security_group_rule(parent_group_id,
- ip_protocol,
- from_port, to_port)
+ resp, rule = \
+ self.client.create_security_group_rule(parent_group_id,
+ ip_protocol,
+ from_port,
+ to_port)
finally:
#Deleting the Security Group rule, created in this method
group_rule_id = rule['id']
@@ -135,21 +138,14 @@
def test_security_group_rules_create_with_invalid_id(self):
# Negative test: Creation of Security Group rule should FAIL
# with invalid Parent group id
- #Adding rules to the invalid Security Group id
+ # Adding rules to the invalid Security Group id
parent_group_id = rand_name('999')
ip_protocol = 'tcp'
from_port = 22
to_port = 22
- try:
- resp, rule =\
- self.client.create_security_group_rule(parent_group_id,
- ip_protocol,
- from_port, to_port)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Security Group rule should not be created '
- 'with invalid parent group id')
+ self.assertRaises(exceptions.NotFound,
+ self.client.create_security_group_rule,
+ parent_group_id, ip_protocol, from_port, to_port)
@attr(type='negative')
def test_security_group_rules_create_with_invalid_ip_protocol(self):
@@ -165,18 +161,11 @@
ip_protocol = rand_name('999')
from_port = 22
to_port = 22
- try:
- resp, rule =\
- self.client.create_security_group_rule(parent_group_id,
- ip_protocol,
- from_port, to_port)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group rule should not be created '
- 'with invalid ip_protocol')
- #Deleting the Security Group created in this method
- resp, _ = self.client.delete_security_group(securitygroup['id'])
+
+ self.addCleanup(self.client.delete_security_group, securitygroup['id'])
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group_rule,
+ parent_group_id, ip_protocol, from_port, to_port)
@attr(type='negative')
def test_security_group_rules_create_with_invalid_from_port(self):
@@ -192,18 +181,10 @@
ip_protocol = 'tcp'
from_port = rand_name('999')
to_port = 22
- try:
- resp, rule =\
- self.client.create_security_group_rule(parent_group_id,
- ip_protocol,
- from_port, to_port)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group rule should not be created'
- 'with invalid from_port')
- #Deleting the Security Group created in this method
- resp, _ = self.client.delete_security_group(securitygroup['id'])
+ self.addCleanup(self.client.delete_security_group, securitygroup['id'])
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group_rule,
+ parent_group_id, ip_protocol, from_port, to_port)
@attr(type='negative')
def test_security_group_rules_create_with_invalid_to_port(self):
@@ -219,30 +200,37 @@
ip_protocol = 'tcp'
from_port = 22
to_port = rand_name('999')
- try:
- resp, rule =\
- self.client.create_security_group_rule(parent_group_id,
- ip_protocol,
- from_port, to_port)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group rule should not be created'
- 'with invalid from_port')
- #Deleting the Security Group created in this method
- resp, _ = self.client.delete_security_group(securitygroup['id'])
+ self.addCleanup(self.client.delete_security_group, securitygroup['id'])
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group_rule,
+ parent_group_id, ip_protocol, from_port, to_port)
+
+ @attr(type='negative')
+ def test_security_group_rules_create_with_invalid_port_range(self):
+ # Negative test: Creation of Security Group rule should FAIL
+ # with invalid port range.
+ # Creating a Security Group to add rule to it.
+ s_name = rand_name('securitygroup-')
+ s_description = rand_name('description-')
+ resp, securitygroup = self.client.create_security_group(s_name,
+ s_description)
+ # Adding a rule to the created Security Group
+ secgroup_id = securitygroup['id']
+ ip_protocol = 'tcp'
+ from_port = 22
+ to_port = 21
+ self.addCleanup(self.client.delete_security_group, securitygroup['id'])
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group_rule,
+ secgroup_id, ip_protocol, from_port, to_port)
@attr(type='negative')
def test_security_group_rules_delete_with_invalid_id(self):
# Negative test: Deletion of Security Group rule should be FAIL
# with invalid rule id
- try:
- self.client.delete_security_group_rule(rand_name('999'))
- except exceptions.NotFound:
- pass
- else:
- self.fail('Security Group Rule should not be deleted '
- 'with nonexistant rule id')
+ self.assertRaises(exceptions.NotFound,
+ self.client.delete_security_group_rule,
+ rand_name('999'))
class SecurityGroupRulesTestXML(SecurityGroupRulesTestJSON):
diff --git a/tempest/tests/compute/security_groups/test_security_groups.py b/tempest/tests/compute/security_groups/test_security_groups.py
index c086280..70a01a0 100644
--- a/tempest/tests/compute/security_groups/test_security_groups.py
+++ b/tempest/tests/compute/security_groups/test_security_groups.py
@@ -38,8 +38,8 @@
for i in range(3):
s_name = rand_name('securitygroup-')
s_description = rand_name('description-')
- resp, securitygroup =\
- self.client.create_security_group(s_name, s_description)
+ resp, securitygroup = \
+ self.client.create_security_group(s_name, s_description)
self.assertEqual(200, resp.status)
security_group_list.append(securitygroup)
#Fetch all Security Groups and verify the list
@@ -47,8 +47,8 @@
resp, fetched_list = self.client.list_security_groups()
self.assertEqual(200, resp.status)
#Now check if all the created Security Groups are in fetched list
- missing_sgs =\
- [sg for sg in security_group_list if sg not in fetched_list]
+ missing_sgs = \
+ [sg for sg in security_group_list if sg not in fetched_list]
self.assertFalse(missing_sgs,
"Failed to find Security Group %s in fetched "
"list" % ', '.join(m_group['name']
@@ -56,8 +56,8 @@
finally:
#Delete all the Security Groups created in this method
for securitygroup in security_group_list:
- resp, _ =\
- self.client.delete_security_group(securitygroup['id'])
+ resp, _ = \
+ self.client.delete_security_group(securitygroup['id'])
self.assertEqual(202, resp.status)
@attr(type='positive')
@@ -67,7 +67,7 @@
s_name = rand_name('securitygroup-')
s_description = rand_name('description-')
resp, securitygroup = \
- self.client.create_security_group(s_name, s_description)
+ self.client.create_security_group(s_name, s_description)
self.assertEqual(200, resp.status)
self.assertTrue('id' in securitygroup)
securitygroup_id = securitygroup['id']
@@ -88,12 +88,12 @@
try:
s_name = rand_name('securitygroup-')
s_description = rand_name('description-')
- resp, securitygroup =\
- self.client.create_security_group(s_name, s_description)
+ resp, securitygroup = \
+ self.client.create_security_group(s_name, s_description)
self.assertEqual(200, resp.status)
#Now fetch the created Security Group by its 'id'
- resp, fetched_group =\
- self.client.get_security_group(securitygroup['id'])
+ resp, fetched_group = \
+ self.client.get_security_group(securitygroup['id'])
self.assertEqual(200, resp.status)
self.assertEqual(securitygroup, fetched_group,
"The fetched Security Group is different "
@@ -116,100 +116,74 @@
non_exist_id = rand_name('999')
if non_exist_id not in security_group_id:
break
- try:
- resp, body = \
- self.client.get_security_group(non_exist_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to GET the details from a '
- 'nonexistant Security Group')
+ self.assertRaises(exceptions.NotFound, self.client.get_security_group,
+ non_exist_id)
@attr(type='negative')
def test_security_group_create_with_invalid_group_name(self):
# Negative test: Security Group should not be created with group name
# as an empty string/with white spaces/chars more than 255
s_description = rand_name('description-')
- #Create Security Group with empty string as group name
- try:
- resp, _ = self.client.create_security_group("", s_description)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group should not be created '
- 'with EMPTY Name')
- #Create Security Group with white space in group name
- try:
- resp, _ = self.client.create_security_group(" ", s_description)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group should not be created '
- 'with WHITE SPACE in Name')
- #Create Security Group with group name longer than 255 chars
+ # Create Security Group with empty string as group name
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group, "", s_description)
+ # Create Security Group with white space in group name
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group, " ",
+ s_description)
+ # Create Security Group with group name longer than 255 chars
s_name = 'securitygroup-'.ljust(260, '0')
- try:
- resp, _ = self.client.create_security_group(s_name, s_description)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group should not be created '
- 'with more than 255 chars in Name')
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group, s_name,
+ s_description)
@attr(type='negative')
def test_security_group_create_with_invalid_group_description(self):
# Negative test:Security Group should not be created with description
# as an empty string/with white spaces/chars more than 255
s_name = rand_name('securitygroup-')
- #Create Security Group with empty string as description
- try:
- resp, _ = self.client.create_security_group(s_name, "")
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group should not be created '
- 'with EMPTY Description')
- #Create Security Group with white space in description
- try:
- resp, _ = self.client.create_security_group(s_name, " ")
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group should not be created '
- 'with WHITE SPACE in Description')
- #Create Security Group with group description longer than 255 chars
+ # Create Security Group with empty string as description
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group, s_name, "")
+ # Create Security Group with white space in description
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group, s_name, " ")
+ # Create Security Group with group description longer than 255 chars
s_description = 'description-'.ljust(260, '0')
- try:
- resp, _ = self.client.create_security_group(s_name, s_description)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group should not be created '
- 'with more than 255 chars in Description')
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group, s_name,
+ s_description)
@attr(type='negative')
def test_security_group_create_with_duplicate_name(self):
# Negative test:Security Group with duplicate name should not
# be created
- try:
- s_name = rand_name('securitygroup-')
- s_description = rand_name('description-')
- resp, security_group =\
+ s_name = rand_name('securitygroup-')
+ s_description = rand_name('description-')
+ resp, security_group =\
self.client.create_security_group(s_name, s_description)
- self.assertEqual(200, resp.status)
- #Now try the Security Group with the same 'Name'
- try:
- resp, _ =\
- self.client.create_security_group(s_name, s_description)
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Security Group should not be created '
- 'with duplicate Group Name')
- finally:
- #Delete the Security Group created in this method
- resp, _ = self.client.delete_security_group(security_group['id'])
- self.assertEqual(202, resp.status)
+ self.assertEqual(200, resp.status)
+
+ self.addCleanup(self.client.delete_security_group,
+ security_group['id'])
+ # Now try the Security Group with the same 'Name'
+ self.assertRaises(exceptions.BadRequest,
+ self.client.create_security_group, s_name,
+ s_description)
+
+ @attr(type='negative')
+ def test_delete_the_default_security_group(self):
+ # Negative test:Deletion of the "default" Security Group should Fail
+ default_security_group_id = None
+ resp, body = self.client.list_security_groups()
+ for i in range(len(body)):
+ if body[i]['name'] == 'default':
+ default_security_group_id = body[i]['id']
+ break
+ #Deleting the "default" Security Group
+ self.assertRaises(exceptions.BadRequest,
+ self.client.delete_security_group,
+ default_security_group_id)
@attr(type='negative')
def test_delete_nonexistant_security_group(self):
@@ -223,25 +197,15 @@
non_exist_id = rand_name('999')
if non_exist_id not in security_group_id:
break
- try:
- resp, body = self.client.delete_security_group(non_exist_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to delete a nonexistant '
- 'Security Group')
+ self.assertRaises(exceptions.NotFound,
+ self.client.delete_security_group, non_exist_id)
@attr(type='negative')
def test_delete_security_group_without_passing_id(self):
# Negative test:Deletion of a Security Group with out passing ID
# should Fail
- try:
- resp, body = self.client.delete_security_group('')
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to delete a Security Group'
- 'with out passing ID')
+ self.assertRaises(exceptions.NotFound,
+ self.client.delete_security_group, '')
def test_server_security_groups(self):
# Checks that security groups may be added and linked to a server
diff --git a/tempest/tests/compute/servers/test_attach_interfaces.py b/tempest/tests/compute/servers/test_attach_interfaces.py
new file mode 100644
index 0000000..47c0575
--- /dev/null
+++ b/tempest/tests/compute/servers/test_attach_interfaces.py
@@ -0,0 +1,112 @@
+# Copyright 2013 IBM Corp.
+# 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.
+
+from tempest import clients
+from tempest.tests.compute import base
+
+import time
+
+
+class AttachInterfacesTestJSON(base.BaseComputeTest):
+ _interface = 'json'
+
+ @classmethod
+ def setUpClass(cls):
+ super(AttachInterfacesTestJSON, cls).setUpClass()
+ os = clients.Manager()
+ if not os.config.network.quantum_available:
+ raise cls.skipException("Quantum is required")
+ cls.client = os.interfaces_client
+
+ def _check_interface(self, iface, port_id=None, network_id=None,
+ fixed_ip=None):
+ self.assertIn('port_state', iface)
+ if port_id:
+ self.assertEqual(iface['port_id'], port_id)
+ if network_id:
+ self.assertEqual(iface['net_id'], network_id)
+ if fixed_ip:
+ self.assertEqual(iface['fixed_ips'][0]['ip_address'], fixed_ip)
+
+ def _create_server_get_interfaces(self):
+ server = self.create_server()
+ self.os.servers_client.wait_for_server_status(server['id'], 'ACTIVE')
+ resp, ifs = self.client.list_interfaces(server['id'])
+ return server, ifs
+
+ def _test_create_interface(self, server):
+ resp, iface = self.client.create_interface(server['id'])
+ self._check_interface(iface)
+ return iface
+
+ def _test_create_interface_by_network_id(self, server, ifs):
+ network_id = ifs[0]['net_id']
+ resp, iface = self.client.create_interface(server['id'],
+ network_id=network_id)
+ self._check_interface(iface, network_id=network_id)
+ return iface
+
+ def _test_show_interface(self, server, ifs):
+ iface = ifs[0]
+ resp, _iface = self.client.show_interface(server['id'],
+ iface['port_id'])
+ self.assertEqual(iface, _iface)
+
+ def _test_delete_interface(self, server, ifs):
+ # NOTE(danms): delete not the first or last, but one in the middle
+ iface = ifs[1]
+ self.client.delete_interface(server['id'], iface['port_id'])
+ for i in range(0, 5):
+ _r, _ifs = self.client.list_interfaces(server['id'])
+ if len(ifs) != len(_ifs):
+ break
+ time.sleep(1)
+
+ self.assertEqual(len(_ifs), len(ifs) - 1)
+ for _iface in _ifs:
+ self.assertNotEqual(iface['port_id'], _iface['port_id'])
+ return _ifs
+
+ def _compare_iface_list(self, list1, list2):
+ # NOTE(danms): port_state will likely have changed, so just
+ # confirm the port_ids are the same at least
+ list1 = [x['port_id'] for x in list1]
+ list2 = [x['port_id'] for x in list2]
+
+ self.assertEqual(sorted(list1), sorted(list2))
+
+ def test_create_list_show_delete_interfaces(self):
+ server, ifs = self._create_server_get_interfaces()
+ interface_count = len(ifs)
+ self.assertTrue(interface_count > 0)
+ self._check_interface(ifs[0])
+
+ iface = self._test_create_interface(server)
+ ifs.append(iface)
+
+ iface = self._test_create_interface_by_network_id(server, ifs)
+ ifs.append(iface)
+
+ resp, _ifs = self.client.list_interfaces(server['id'])
+ self._compare_iface_list(ifs, _ifs)
+
+ self._test_show_interface(server, ifs)
+
+ _ifs = self._test_delete_interface(server, ifs)
+ self.assertEqual(len(ifs) - 1, len(_ifs))
+
+
+class AttachInterfacesTestXML(AttachInterfacesTestJSON):
+ _interface = 'xml'
diff --git a/tempest/tests/compute/servers/test_create_server.py b/tempest/tests/compute/servers/test_create_server.py
index 3c8aeda..aaab9fa 100644
--- a/tempest/tests/compute/servers/test_create_server.py
+++ b/tempest/tests/compute/servers/test_create_server.py
@@ -46,24 +46,17 @@
personality = [{'path': '/test.txt',
'contents': base64.b64encode(file_contents)}]
cls.client = cls.servers_client
- cli_resp = cls.client.create_server(cls.name,
- cls.image_ref,
- cls.flavor_ref,
- meta=cls.meta,
- accessIPv4=cls.accessIPv4,
- accessIPv6=cls.accessIPv6,
- personality=personality,
- disk_config=cls.disk_config)
+ cli_resp = cls.create_server(name=cls.name,
+ meta=cls.meta,
+ accessIPv4=cls.accessIPv4,
+ accessIPv6=cls.accessIPv6,
+ personality=personality,
+ disk_config=cls.disk_config)
cls.resp, cls.server_initial = cli_resp
cls.password = cls.server_initial['adminPass']
cls.client.wait_for_server_status(cls.server_initial['id'], 'ACTIVE')
resp, cls.server = cls.client.get_server(cls.server_initial['id'])
- @classmethod
- def tearDownClass(cls):
- cls.client.delete_server(cls.server_initial['id'])
- super(ServersTestJSON, cls).tearDownClass()
-
@attr(type='smoke')
def test_create_server_response(self):
# Check that the required fields are returned with values
diff --git a/tempest/tests/compute/servers/test_disk_config.py b/tempest/tests/compute/servers/test_disk_config.py
index 3a1ec20..2fbb876 100644
--- a/tempest/tests/compute/servers/test_disk_config.py
+++ b/tempest/tests/compute/servers/test_disk_config.py
@@ -17,7 +17,6 @@
import testtools
-from tempest.common.utils.data_utils import rand_name
from tempest.test import attr
from tempest.tests import compute
from tempest.tests.compute import base
diff --git a/tempest/tests/compute/servers/test_server_addresses.py b/tempest/tests/compute/servers/test_server_addresses.py
index b811d52..4807d1e 100644
--- a/tempest/tests/compute/servers/test_server_addresses.py
+++ b/tempest/tests/compute/servers/test_server_addresses.py
@@ -43,26 +43,15 @@
@attr(type='negative', category='server-addresses')
def test_list_server_addresses_invalid_server_id(self):
# List addresses request should fail if server id not in system
-
- try:
- self.client.list_addresses('999')
- except exceptions.NotFound:
- pass
- else:
- self.fail('The server rebuild for a non existing server should not'
- ' be allowed')
+ self.assertRaises(exceptions.NotFound, self.client.list_addresses,
+ '999')
@attr(type='negative', category='server-addresses')
def test_list_server_addresses_by_network_neg(self):
# List addresses by network should fail if network name not valid
-
- try:
- self.client.list_addresses_by_network(self.server['id'], 'invalid')
- except exceptions.NotFound:
- pass
- else:
- self.fail('The server rebuild for a non existing server should not'
- ' be allowed')
+ self.assertRaises(exceptions.NotFound,
+ self.client.list_addresses_by_network,
+ self.server['id'], 'invalid')
@attr(type='smoke', category='server-addresses')
def test_list_server_addresses(self):
@@ -99,3 +88,7 @@
addr = addr[addr_type]
for address in addresses[addr_type]:
self.assertTrue(any([a for a in addr if a == address]))
+
+
+class ServerAddressesTestXML(ServerAddressesTest):
+ _interface = 'xml'
diff --git a/tempest/tests/compute/servers/test_server_metadata.py b/tempest/tests/compute/servers/test_server_metadata.py
index 4b17fa2..bc523de 100644
--- a/tempest/tests/compute/servers/test_server_metadata.py
+++ b/tempest/tests/compute/servers/test_server_metadata.py
@@ -15,28 +15,25 @@
# License for the specific language governing permissions and limitations
# under the License.
-from tempest.common.utils.data_utils import rand_name
from tempest import exceptions
from tempest.test import attr
from tempest.tests.compute import base
-class ServerMetadataTest(base.BaseComputeTest):
+class ServerMetadataTestJSON(base.BaseComputeTest):
_interface = 'json'
@classmethod
def setUpClass(cls):
- super(ServerMetadataTest, cls).setUpClass()
+ super(ServerMetadataTestJSON, cls).setUpClass()
cls.client = cls.servers_client
cls.quotas = cls.quotas_client
cls.admin_client = cls._get_identity_admin_client()
resp, tenants = cls.admin_client.list_tenants()
cls.tenant_id = [tnt['id'] for tnt in tenants if tnt['name'] ==
cls.client.tenant_name][0]
- #Create a server to be used for all read only tests
- name = rand_name('server')
- resp, server = cls.client.create_server(name, cls.image_ref,
- cls.flavor_ref, meta={})
+ resp, server = cls.create_server(meta={})
+
cls.server_id = server['id']
#Wait for the server to become active
@@ -45,10 +42,10 @@
@classmethod
def tearDownClass(cls):
cls.client.delete_server(cls.server_id)
- super(ServerMetadataTest, cls).tearDownClass()
+ super(ServerMetadataTestJSON, cls).tearDownClass()
def setUp(self):
- super(ServerMetadataTest, self).setUp()
+ super(ServerMetadataTestJSON, self).setUp()
meta = {'key1': 'value1', 'key2': 'value2'}
resp, _ = self.client.set_server_metadata(self.server_id, meta)
self.assertEqual(resp.status, 200)
@@ -238,3 +235,7 @@
self.assertRaises(exceptions.BadRequest,
self.client.set_server_metadata,
self.server_id, meta=meta)
+
+
+class ServerMetadataTestXML(ServerMetadataTestJSON):
+ _interface = 'xml'
diff --git a/tempest/tests/compute/servers/test_server_personality.py b/tempest/tests/compute/servers/test_server_personality.py
index 0bafc2c..c529c43 100644
--- a/tempest/tests/compute/servers/test_server_personality.py
+++ b/tempest/tests/compute/servers/test_server_personality.py
@@ -17,7 +17,6 @@
import base64
-from tempest.common.utils.data_utils import rand_name
from tempest import exceptions
from tempest.test import attr
from tempest.tests.compute import base
diff --git a/tempest/tests/compute/servers/test_servers_negative.py b/tempest/tests/compute/servers/test_servers_negative.py
index 366b630..9013b36 100644
--- a/tempest/tests/compute/servers/test_servers_negative.py
+++ b/tempest/tests/compute/servers/test_servers_negative.py
@@ -29,7 +29,6 @@
@classmethod
def setUpClass(cls):
- raise cls.skipException("Until Bug 1046870 is fixed")
super(ServersNegativeTest, cls).setUpClass()
cls.client = cls.servers_client
cls.img_client = cls.images_client
@@ -115,6 +114,8 @@
@attr(type='negative')
def test_create_numeric_server_name(self):
# Create a server with a numeric name
+ if self.__class__._interface == "xml":
+ raise self.skipException("Not testable in XML")
server_name = 12345
self.assertRaises(exceptions.BadRequest,
@@ -182,7 +183,7 @@
def test_update_server_of_another_tenant(self):
# Update name of a server that belongs to another tenant
- server = self.create_server()
+ resp, server = self.create_server(wait_until='ACTIVE')
new_name = server['id'] + '_new'
self.assertRaises(exceptions.NotFound,
self.alt_client.update_server, server['id'],
@@ -192,7 +193,7 @@
def test_update_server_name_length_exceeds_256(self):
# Update name of server exceed the name length limit
- server = self.create_server()
+ resp, server = self.create_server(wait_until='ACTIVE')
new_name = 'a' * 256
self.assertRaises(exceptions.BadRequest,
self.client.update_server,
@@ -210,7 +211,7 @@
def test_delete_a_server_of_another_tenant(self):
# Delete a server that belongs to another tenant
try:
- server = self.create_server()
+ resp, server = self.create_server(wait_until='ACTIVE')
self.assertRaises(exceptions.NotFound,
self.alt_client.delete_server,
server['id'])
@@ -245,3 +246,7 @@
self.assertRaises(exceptions.NotFound, self.client.get_server,
'999erra43')
+
+
+class ServersNegativeTestXML(ServersNegativeTest):
+ _interface = 'xml'
diff --git a/tempest/tests/compute/test_live_block_migration.py b/tempest/tests/compute/test_live_block_migration.py
index dcd6a78..abaaf85 100644
--- a/tempest/tests/compute/test_live_block_migration.py
+++ b/tempest/tests/compute/test_live_block_migration.py
@@ -86,7 +86,7 @@
if 'ACTIVE' == self._get_server_status(server_id):
return server_id
else:
- server = self.create_server()
+ _, server = self.create_server(wait_until="ACTIVE")
server_id = server['id']
self.password = server['adminPass']
self.password = 'password'
@@ -108,7 +108,6 @@
self.servers_client.wait_for_server_status(server_id, 'ACTIVE')
self.assertEquals(target_host, self._get_host_for_server(server_id))
- @testtools.skip('Until bug 1051881 is dealt with.')
@testtools.skipIf(not live_migration_available,
'Block Live migration not available')
def test_invalid_host_for_migration(self):
diff --git a/tempest/tests/compute/volumes/test_volumes_negative.py b/tempest/tests/compute/volumes/test_volumes_negative.py
index c0fa565..306b93b 100644
--- a/tempest/tests/compute/volumes/test_volumes_negative.py
+++ b/tempest/tests/compute/volumes/test_volumes_negative.py
@@ -39,18 +39,13 @@
non_exist_id = rand_name('999')
if non_exist_id not in volume_id_list:
break
- #Trying to GET a non existant volume
- try:
- resp, body = self.client.get_volume(non_exist_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to GET the details from a '
- 'nonexistant volume')
+ # Trying to GET a non existant volume
+ self.assertRaises(exceptions.NotFound, self.client.get_volume,
+ non_exist_id)
def test_volume_delete_nonexistant_volume_id(self):
# Negative: Should not be able to delete nonexistant Volume
- #Creating nonexistant volume id
+ # Creating nonexistant volume id
volume_id_list = list()
resp, body = self.client.list_volumes()
for i in range(len(body)):
@@ -59,13 +54,9 @@
non_exist_id = rand_name('999')
if non_exist_id not in volume_id_list:
break
- #Trying to DELETE a non existant volume
- try:
- resp, body = self.client.delete_volume(non_exist_id)
- except exceptions.NotFound:
- pass
- else:
- self.fail('Should not be able to DELETE a nonexistant volume')
+ # Trying to DELETE a non existant volume
+ self.assertRaises(exceptions.NotFound, self.client.delete_volume,
+ non_exist_id)
def test_create_volume_with_invalid_size(self):
# Negative: Should not be able to create volume with invalid size
diff --git a/tempest/tests/identity/admin/test_roles.py b/tempest/tests/identity/admin/test_roles.py
index 53c5b0d..f71bed0 100644
--- a/tempest/tests/identity/admin/test_roles.py
+++ b/tempest/tests/identity/admin/test_roles.py
@@ -95,15 +95,9 @@
role1_id = body.get('id')
self.assertTrue('status' in resp)
self.assertTrue(resp['status'].startswith('2'))
-
- try:
- resp, body = self.client.create_role(role_name)
- # this should raise an exception
- self.fail('Should not be able to create a duplicate role name.'
- ' %s' % role_name)
- except exceptions.Duplicate:
- pass
- self.client.delete_role(role1_id)
+ self.addCleanup(self.client.delete_role, role1_id)
+ self.assertRaises(exceptions.Duplicate, self.client.create_role,
+ role_name)
def test_assign_user_role(self):
# Assign a role to a user on a tenant
diff --git a/tempest/tests/identity/admin/test_tenants.py b/tempest/tests/identity/admin/test_tenants.py
index a3c9246..8155eb5 100644
--- a/tempest/tests/identity/admin/test_tenants.py
+++ b/tempest/tests/identity/admin/test_tenants.py
@@ -151,14 +151,10 @@
self.data.tenants.append(tenant)
tenant1_id = body.get('id')
- try:
- resp, body = self.client.create_tenant(tenant_name)
- # this should have raised an exception
- self.fail('Should not be able to create a duplicate tenant name')
- except exceptions.Duplicate:
- pass
- self.client.delete_tenant(tenant1_id)
- self.data.tenants.remove(tenant)
+ self.addCleanup(self.client.delete_tenant, tenant1_id)
+ self.addCleanup(self.data.tenants.remove, tenant)
+ self.assertRaises(exceptions.Duplicate, self.client.create_tenant,
+ tenant_name)
@attr(type='negative')
def test_create_tenant_by_unauthorized_user(self):
diff --git a/tempest/tests/image/test_images.py b/tempest/tests/image/test_images.py
deleted file mode 100644
index 6ac852e..0000000
--- a/tempest/tests/image/test_images.py
+++ /dev/null
@@ -1,172 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2012 OpenStack, LLC
-# 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 cStringIO as StringIO
-import random
-
-import tempest.test
-
-from tempest.test import attr
-
-
-from tempest import clients
-from tempest import exceptions
-
-
-class CreateRegisterImagesTest(tempest.test.BaseTestCase):
-
- """
- Here we test the registration and creation of images
- """
-
- @classmethod
- def setUpClass(cls):
- cls.os = clients.Manager()
- cls.client = cls.os.image_client
- cls.created_images = []
-
- @classmethod
- def tearDownClass(cls):
- for image_id in cls.created_images:
- cls.client.delete(image_id)
-
- @attr(type='negative')
- def test_register_with_invalid_container_format(self):
- # Negative tests for invalid data supplied to POST /images
- try:
- resp, body = self.client.create_image('test', 'wrong', 'vhd')
- except exceptions.BadRequest:
- pass
- else:
- self.fail('Invalid container format should not be accepted')
-
- @attr(type='negative')
- def test_register_with_invalid_disk_format(self):
- try:
- resp, body = self.client.create_image('test', 'bare', 'wrong')
- except exceptions.BadRequest:
- pass
- else:
- self.fail("Invalid disk format should not be accepted")
-
- @attr(type='image')
- def test_register_then_upload(self):
- # Register, then upload an image
- properties = {'prop1': 'val1'}
- resp, body = self.client.create_image('New Name', 'bare', 'raw',
- is_public=True,
- properties=properties)
- self.assertTrue('id' in body)
- image_id = body.get('id')
- self.created_images.append(image_id)
- self.assertTrue('name' in body)
- self.assertEqual('New Name', body.get('name'))
- self.assertTrue('is_public' in body)
- self.assertTrue(body.get('is_public'))
- self.assertTrue('status' in body)
- self.assertEqual('queued', body.get('status'))
- self.assertTrue('properties' in body)
- for key, val in properties.items():
- self.assertEqual(val, body.get('properties')[key])
-
- # Now try uploading an image file
- image_file = StringIO.StringIO(('*' * 1024))
- resp, body = self.client.update_image(image_id, data=image_file)
- self.assertTrue('size' in body)
- self.assertEqual(1024, body.get('size'))
-
- @attr(type='image')
- def test_register_remote_image(self):
- # Register a new remote image
- resp, body = self.client.create_image('New Remote Image', 'bare',
- 'raw', is_public=True,
- location='http://example.com'
- '/someimage.iso')
- self.assertTrue('id' in body)
- image_id = body.get('id')
- self.created_images.append(image_id)
- self.assertTrue('name' in body)
- self.assertEqual('New Remote Image', body.get('name'))
- self.assertTrue('is_public' in body)
- self.assertTrue(body.get('is_public'))
- self.assertTrue('status' in body)
- self.assertEqual('active', body.get('status'))
-
-
-class ListImagesTest(tempest.test.BaseTestCase):
-
- """
- Here we test the listing of image information
- """
-
- @classmethod
- def setUpClass(cls):
- cls.os = clients.Manager()
- cls.client = cls.os.image_client
- cls.created_images = []
-
- # We add a few images here to test the listing functionality of
- # the images API
- for x in xrange(0, 10):
- # We make even images remote and odd images standard
- if x % 2 == 0:
- cls.created_images.append(cls._create_remote_image(x))
- else:
- cls.created_images.append(cls._create_standard_image(x))
-
- @classmethod
- def tearDownClass(cls):
- for image_id in cls.created_images:
- cls.client.delete_image(image_id)
- cls.client.wait_for_resource_deletion(image_id)
-
- @classmethod
- def _create_remote_image(cls, x):
- """
- Create a new remote image and return the ID of the newly-registered
- image
- """
- name = 'New Remote Image %s' % x
- location = 'http://example.com/someimage_%s.iso' % x
- resp, body = cls.client.create_image(name, 'bare', 'raw',
- is_public=True,
- location=location)
- image_id = body['id']
- return image_id
-
- @classmethod
- def _create_standard_image(cls, x):
- """
- Create a new standard image and return the ID of the newly-registered
- image. Note that the size of the new image is a random number between
- 1024 and 4096
- """
- image_file = StringIO.StringIO('*' * random.randint(1024, 4096))
- name = 'New Standard Image %s' % x
- resp, body = cls.client.create_image(name, 'bare', 'raw',
- is_public=True, data=image_file)
- image_id = body['id']
- return image_id
-
- @attr(type='image')
- def test_index_no_params(self):
- # Simple test to see all fixture images returned
- resp, images_list = self.client.image_list()
- self.assertEqual(resp['status'], '200')
- image_list = map(lambda x: x['id'], images_list)
- for image in self.created_images:
- self.assertTrue(image in image_list)
diff --git a/tempest/services/image/json/__init__.py b/tempest/tests/image/v1/__init__.py
similarity index 100%
copy from tempest/services/image/json/__init__.py
copy to tempest/tests/image/v1/__init__.py
diff --git a/tempest/tests/image/v1/test_image_members.py b/tempest/tests/image/v1/test_image_members.py
new file mode 100644
index 0000000..30fa6c6
--- /dev/null
+++ b/tempest/tests/image/v1/test_image_members.py
@@ -0,0 +1,93 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2013 IBM Corp.
+#
+# 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 cStringIO as StringIO
+
+from tempest import clients
+import tempest.test
+
+
+class ImageMembersTests(tempest.test.BaseTestCase):
+
+ @classmethod
+ def setUpClass(cls):
+ cls.os = clients.Manager()
+ cls.client = cls.os.image_client
+ admin = clients.AdminManager(interface='json')
+ cls.admin_client = admin.identity_client
+ cls.created_images = []
+ cls.tenants = cls._get_tenants()
+
+ @classmethod
+ def tearDownClass(cls):
+ for image_id in cls.created_images:
+ cls.client.delete_image(image_id)
+ cls.client.wait_for_resource_deletion(image_id)
+
+ @classmethod
+ def _get_tenants(cls):
+ resp, tenants = cls.admin_client.list_tenants()
+ tenants = map(lambda x: x['id'], tenants)
+ return tenants
+
+ def _create_image(self, name=None):
+ image_file = StringIO.StringIO('*' * 1024)
+ if name is not None:
+ name = 'New Standard Image with Members'
+ resp, image = self.client.create_image(name,
+ 'bare', 'raw',
+ is_public=True, data=image_file)
+ self.assertEquals(201, resp.status)
+ image_id = image['id']
+ self.created_images.append(image_id)
+ return image_id
+
+ def test_add_image_member(self):
+ image = self._create_image()
+ resp = self.client.add_member(self.tenants[0], image)
+ self.assertEquals(204, resp.status)
+ resp, body = self.client.get_image_membership(image)
+ self.assertEquals(200, resp.status)
+ members = body['members']
+ members = map(lambda x: x['member_id'], members)
+ self.assertIn(self.tenants[0], members)
+
+ def test_get_shared_images(self):
+ image = self._create_image()
+ resp = self.client.add_member(self.tenants[0], image)
+ self.assertEquals(204, resp.status)
+ name = 'Shared Image'
+ share_image = self._create_image(name=name)
+ resp = self.client.add_member(self.tenants[0], share_image)
+ self.assertEquals(204, resp.status)
+ resp, body = self.client.get_shared_images(self.tenants[0])
+ self.assertEquals(200, resp.status)
+ images = body['shared_images']
+ images = map(lambda x: x['image_id'], images)
+ self.assertIn(share_image, images)
+ self.assertIn(image, images)
+
+ def test_remove_member(self):
+ name = 'Shared Image for Delete Test'
+ image_id = self._create_image(name=name)
+ resp = self.client.add_member(self.tenants[0], image_id)
+ self.assertEquals(204, resp.status)
+ resp = self.client.delete_member(self.tenants[0], image_id)
+ self.assertEquals(204, resp.status)
+ resp, body = self.client.get_image_membership(image_id)
+ self.assertEquals(200, resp.status)
+ members = body['members']
+ self.assertEquals(0, len(members))
diff --git a/tempest/tests/image/v1/test_images.py b/tempest/tests/image/v1/test_images.py
new file mode 100644
index 0000000..84bb650
--- /dev/null
+++ b/tempest/tests/image/v1/test_images.py
@@ -0,0 +1,244 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2012 OpenStack, LLC
+# 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 cStringIO as StringIO
+
+from tempest import clients
+from tempest import exceptions
+import tempest.test
+from tempest.test import attr
+
+
+class CreateRegisterImagesTest(tempest.test.BaseTestCase):
+
+ """
+ Here we test the registration and creation of images
+ """
+
+ @classmethod
+ def setUpClass(cls):
+ cls.os = clients.Manager()
+ cls.client = cls.os.image_client
+ cls.created_images = []
+
+ @classmethod
+ def tearDownClass(cls):
+ for image_id in cls.created_images:
+ cls.client.delete(image_id)
+
+ @attr(type='negative')
+ def test_register_with_invalid_container_format(self):
+ # Negative tests for invalid data supplied to POST /images
+ self.assertRaises(exceptions.BadRequest, self.client.create_image,
+ 'test', 'wrong', 'vhd')
+
+ @attr(type='negative')
+ def test_register_with_invalid_disk_format(self):
+ self.assertRaises(exceptions.BadRequest, self.client.create_image,
+ 'test', 'bare', 'wrong')
+
+ @attr(type='image')
+ def test_register_then_upload(self):
+ # Register, then upload an image
+ properties = {'prop1': 'val1'}
+ resp, body = self.client.create_image('New Name', 'bare', 'raw',
+ is_public=True,
+ properties=properties)
+ self.assertTrue('id' in body)
+ image_id = body.get('id')
+ self.created_images.append(image_id)
+ self.assertTrue('name' in body)
+ self.assertEqual('New Name', body.get('name'))
+ self.assertTrue('is_public' in body)
+ self.assertTrue(body.get('is_public'))
+ self.assertTrue('status' in body)
+ self.assertEqual('queued', body.get('status'))
+ self.assertTrue('properties' in body)
+ for key, val in properties.items():
+ self.assertEqual(val, body.get('properties')[key])
+
+ # Now try uploading an image file
+ image_file = StringIO.StringIO(('*' * 1024))
+ resp, body = self.client.update_image(image_id, data=image_file)
+ self.assertTrue('size' in body)
+ self.assertEqual(1024, body.get('size'))
+
+ @attr(type='image')
+ def test_register_remote_image(self):
+ # Register a new remote image
+ resp, body = self.client.create_image('New Remote Image', 'bare',
+ 'raw', is_public=True,
+ location='http://example.com'
+ '/someimage.iso')
+ self.assertTrue('id' in body)
+ image_id = body.get('id')
+ self.created_images.append(image_id)
+ self.assertTrue('name' in body)
+ self.assertEqual('New Remote Image', body.get('name'))
+ self.assertTrue('is_public' in body)
+ self.assertTrue(body.get('is_public'))
+ self.assertTrue('status' in body)
+ self.assertEqual('active', body.get('status'))
+
+
+class ListImagesTest(tempest.test.BaseTestCase):
+
+ """
+ Here we test the listing of image information
+ """
+
+ @classmethod
+ def setUpClass(cls):
+ cls.os = clients.Manager()
+ cls.client = cls.os.image_client
+ cls.created_images = []
+
+ # We add a few images here to test the listing functionality of
+ # the images API
+ img1 = cls._create_remote_image('one', 'bare', 'raw')
+ img2 = cls._create_remote_image('two', 'ami', 'ami')
+ img3 = cls._create_remote_image('dup', 'bare', 'raw')
+ img4 = cls._create_remote_image('dup', 'bare', 'raw')
+ img5 = cls._create_standard_image('1', 'ami', 'ami', 42)
+ img6 = cls._create_standard_image('2', 'ami', 'ami', 142)
+ img7 = cls._create_standard_image('33', 'bare', 'raw', 142)
+ img8 = cls._create_standard_image('33', 'bare', 'raw', 142)
+ cls.created_set = set(cls.created_images)
+ # 4x-4x remote image
+ cls.remote_set = set((img1, img2, img3, img4))
+ cls.standard_set = set((img5, img6, img7, img8))
+ # 5x bare, 3x ami
+ cls.bare_set = set((img1, img3, img4, img7, img8))
+ cls.ami_set = set((img2, img5, img6))
+ # 1x with size 42
+ cls.size42_set = set((img5,))
+ # 3x with size 142
+ cls.size142_set = set((img6, img7, img8))
+ # dup named
+ cls.dup_set = set((img3, img4))
+
+ @classmethod
+ def tearDownClass(cls):
+ for image_id in cls.created_images:
+ cls.client.delete_image(image_id)
+ cls.client.wait_for_resource_deletion(image_id)
+
+ @classmethod
+ def _create_remote_image(cls, name, container_format, disk_format):
+ """
+ Create a new remote image and return the ID of the newly-registered
+ image
+ """
+ name = 'New Remote Image %s' % name
+ location = 'http://example.com/someimage_%s.iso' % name
+ resp, image = cls.client.create_image(name,
+ container_format, disk_format,
+ is_public=True,
+ location=location)
+ image_id = image['id']
+ cls.created_images.append(image_id)
+ return image_id
+
+ @classmethod
+ def _create_standard_image(cls, name, container_format,
+ disk_format, size):
+ """
+ Create a new standard image and return the ID of the newly-registered
+ image. Note that the size of the new image is a random number between
+ 1024 and 4096
+ """
+ image_file = StringIO.StringIO('*' * size)
+ name = 'New Standard Image %s' % name
+ resp, image = cls.client.create_image(name,
+ container_format, disk_format,
+ is_public=True, data=image_file)
+ image_id = image['id']
+ cls.created_images.append(image_id)
+ return image_id
+
+ @attr(type='image')
+ def test_index_no_params(self):
+ # Simple test to see all fixture images returned
+ resp, images_list = self.client.image_list()
+ self.assertEqual(resp['status'], '200')
+ image_list = map(lambda x: x['id'], images_list)
+ for image_id in self.created_images:
+ self.assertTrue(image_id in image_list)
+
+ @attr(type='image')
+ def test_index_disk_format(self):
+ resp, images_list = self.client.image_list(disk_format='ami')
+ self.assertEqual(resp['status'], '200')
+ for image in images_list:
+ self.assertEqual(image['disk_format'], 'ami')
+ result_set = set(map(lambda x: x['id'], images_list))
+ self.assertTrue(self.ami_set <= result_set)
+ self.assertFalse(self.created_set - self.ami_set <= result_set)
+
+ @attr(type='image')
+ def test_index_container_format(self):
+ resp, images_list = self.client.image_list(container_format='bare')
+ self.assertEqual(resp['status'], '200')
+ for image in images_list:
+ self.assertEqual(image['container_format'], 'bare')
+ result_set = set(map(lambda x: x['id'], images_list))
+ self.assertTrue(self.bare_set <= result_set)
+ self.assertFalse(self.created_set - self.bare_set <= result_set)
+
+ @attr(type='image')
+ def test_index_max_size(self):
+ resp, images_list = self.client.image_list(size_max=42)
+ self.assertEqual(resp['status'], '200')
+ for image in images_list:
+ self.assertTrue(image['size'] <= 42)
+ result_set = set(map(lambda x: x['id'], images_list))
+ self.assertTrue(self.size42_set <= result_set)
+ self.assertFalse(self.created_set - self.size42_set <= result_set)
+
+ @attr(type='image')
+ def test_index_min_size(self):
+ resp, images_list = self.client.image_list(size_min=142)
+ self.assertEqual(resp['status'], '200')
+ for image in images_list:
+ self.assertTrue(image['size'] >= 142)
+ result_set = set(map(lambda x: x['id'], images_list))
+ self.assertTrue(self.size142_set <= result_set)
+ self.assertFalse(self.size42_set <= result_set)
+
+ @attr(type='image')
+ def test_index_status_active_detail(self):
+ resp, images_list = self.client.image_list_detail(status='active',
+ sort_key='size',
+ sort_dir='desc')
+ self.assertEqual(resp['status'], '200')
+ top_size = images_list[0]['size'] # We have non-zero sized images
+ for image in images_list:
+ size = image['size']
+ self.assertTrue(size <= top_size)
+ top_size = size
+ self.assertEqual(image['status'], 'active')
+
+ @attr(type='image')
+ def test_index_name(self):
+ resp, images_list = self.client.image_list_detail(
+ name='New Remote Image dup')
+ self.assertEqual(resp['status'], '200')
+ result_set = set(map(lambda x: x['id'], images_list))
+ for image in images_list:
+ self.assertEqual(image['name'], 'New Remote Image dup')
+ self.assertTrue(self.dup_set <= result_set)
+ self.assertFalse(self.created_set - self.dup_set <= result_set)
diff --git a/tempest/services/image/json/__init__.py b/tempest/tests/image/v2/__init__.py
similarity index 100%
copy from tempest/services/image/json/__init__.py
copy to tempest/tests/image/v2/__init__.py
diff --git a/tempest/tests/image/v2/test_images.py b/tempest/tests/image/v2/test_images.py
new file mode 100644
index 0000000..9abf28d
--- /dev/null
+++ b/tempest/tests/image/v2/test_images.py
@@ -0,0 +1,126 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2013 OpenStack, LLC
+# All Rights Reserved.
+# Copyright 2013 IBM Corp
+#
+# 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 cStringIO as StringIO
+import random
+
+from tempest import clients
+from tempest import exceptions
+import tempest.test
+from tempest.test import attr
+
+
+class CreateRegisterImagesTest(tempest.test.BaseTestCase):
+
+ """
+ Here we test the registration and creation of images
+ """
+
+ @classmethod
+ def setUpClass(cls):
+ cls.os = clients.Manager()
+ cls.client = cls.os.image_client_v2
+ cls.created_images = []
+
+ @classmethod
+ def tearDownClass(cls):
+ for image_id in cls.created_images:
+ cls.client.delete(image_id)
+
+ @attr(type='negative')
+ def test_register_with_invalid_container_format(self):
+ # Negative tests for invalid data supplied to POST /images
+ self.assertRaises(exceptions.BadRequest, self.client.create_image,
+ 'test', 'wrong', 'vhd')
+
+ @attr(type='negative')
+ def test_register_with_invalid_disk_format(self):
+ self.assertRaises(exceptions.BadRequest, self.client.create_image,
+ 'test', 'bare', 'wrong')
+
+ @attr(type='image')
+ def test_register_then_upload(self):
+ # Register, then upload an image
+ resp, body = self.client.create_image('New Name', 'bare', 'raw',
+ is_public=True)
+ self.assertTrue('id' in body)
+ image_id = body.get('id')
+ self.created_images.append(image_id)
+ self.assertTrue('name' in body)
+ self.assertEqual('New Name', body.get('name'))
+ self.assertTrue('visibility' in body)
+ self.assertTrue(body.get('visibility') == 'public')
+ self.assertTrue('status' in body)
+ self.assertEqual('queued', body.get('status'))
+
+ # Now try uploading an image file
+ image_file = StringIO.StringIO(('*' * 1024))
+ resp, body = self.client.store_image(image_id, image_file)
+ self.assertEqual(resp.status, 204)
+ resp, body = self.client.get_image_metadata(image_id)
+ self.assertTrue('size' in body)
+ self.assertEqual(1024, body.get('size'))
+
+
+class ListImagesTest(tempest.test.BaseTestCase):
+
+ """
+ Here we test the listing of image information
+ """
+
+ @classmethod
+ def setUpClass(cls):
+ cls.os = clients.Manager()
+ cls.client = cls.os.image_client_v2
+ cls.created_images = []
+
+ # We add a few images here to test the listing functionality of
+ # the images API
+ for x in xrange(0, 10):
+ cls.created_images.append(cls._create_standard_image(x))
+
+ @classmethod
+ def tearDownClass(cls):
+ for image_id in cls.created_images:
+ cls.client.delete_image(image_id)
+ cls.client.wait_for_resource_deletion(image_id)
+
+ @classmethod
+ def _create_standard_image(cls, number):
+ """
+ Create a new standard image and return the ID of the newly-registered
+ image. Note that the size of the new image is a random number between
+ 1024 and 4096
+ """
+ image_file = StringIO.StringIO('*' * random.randint(1024, 4096))
+ name = 'New Standard Image %s' % number
+ resp, body = cls.client.create_image(name, 'bare', 'raw',
+ is_public=True)
+ image_id = body['id']
+ resp, body = cls.client.store_image(image_id, data=image_file)
+
+ return image_id
+
+ @attr(type='image')
+ def test_index_no_params(self):
+ # Simple test to see all fixture images returned
+ resp, images_list = self.client.image_list()
+ self.assertEqual(resp['status'], '200')
+ image_list = map(lambda x: x['id'], images_list)
+ for image in self.created_images:
+ self.assertTrue(image in image_list)
diff --git a/tempest/tests/network/base.py b/tempest/tests/network/base.py
index 4cc8b29..1b09513 100644
--- a/tempest/tests/network/base.py
+++ b/tempest/tests/network/base.py
@@ -18,7 +18,6 @@
from tempest import clients
from tempest.common.utils.data_utils import rand_name
-from tempest import exceptions
import tempest.test
@@ -27,15 +26,9 @@
@classmethod
def setUpClass(cls):
os = clients.Manager()
- client = os.network_client
- # Validate that there is even an endpoint configured
- # for networks, and mark the attr for skipping if not
- try:
- client.list_networks()
- except exceptions.EndpointNotFound:
- skip_msg = "No OpenStack Network API endpoint"
- raise cls.skipException(skip_msg)
+ if not os.config.network.quantum_available:
+ raise cls.skipException("Quantum support is required")
@classmethod
def tearDownClass(cls):
diff --git a/tools/install_venv_common.py b/tools/install_venv_common.py
index 8f91251..fd9076f 100644
--- a/tools/install_venv_common.py
+++ b/tools/install_venv_common.py
@@ -21,20 +21,12 @@
Synced in from openstack-common
"""
+import argparse
import os
import subprocess
import sys
-possible_topdir = os.getcwd()
-if os.path.exists(os.path.join(possible_topdir, "tempest",
- "__init__.py")):
- sys.path.insert(0, possible_topdir)
-
-
-from tempest.openstack.common import cfg
-
-
class InstallVenv(object):
def __init__(self, root, venv, pip_requires, test_requires, py_version,
@@ -139,17 +131,12 @@
def parse_args(self, argv):
"""Parses command-line arguments."""
- cli_opts = [
- cfg.BoolOpt('no-site-packages',
- default=False,
- short='n',
- help="Do not inherit packages from global Python"
- "install"),
- ]
- CLI = cfg.ConfigOpts()
- CLI.register_cli_opts(cli_opts)
- CLI(argv[1:])
- return CLI
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-n', '--no-site-packages',
+ action='store_true',
+ help="Do not inherit packages from global Python "
+ "install")
+ return parser.parse_args(argv[1:])
class Distro(InstallVenv):
diff --git a/tools/pip-requires b/tools/pip-requires
index 5c45a49..ee21065 100644
--- a/tools/pip-requires
+++ b/tools/pip-requires
@@ -1,7 +1,7 @@
anyjson
nose
httplib2>=0.7.0
-testtools
+testtools>=0.9.29
lxml
boto>=2.2.1
paramiko
@@ -13,3 +13,5 @@
testresources
keyring
testrepository
+
+http://tarballs.openstack.org/oslo-config/oslo.config-1.1.0b1.tar.gz#egg=oslo.config
diff --git a/tools/tempest_coverage.py b/tools/tempest_coverage.py
index 267eafa..a46d0fb 100755
--- a/tools/tempest_coverage.py
+++ b/tools/tempest_coverage.py
@@ -20,9 +20,10 @@
import shutil
import sys
+from oslo.config import cfg
+
from tempest.common.rest_client import RestClient
from tempest import config
-from tempest.openstack.common import cfg
from tempest.tests.compute import base
CONF = config.TempestConfig()
diff --git a/tox.ini b/tox.ini
index 1b18586..92ce6bc 100644
--- a/tox.ini
+++ b/tox.ini
@@ -19,5 +19,4 @@
python -m tools/tempest_coverage -c report --html
[testenv:pep8]
-deps = pep8==1.3.3
commands = python tools/hacking.py --ignore=E122,E125,E126 --repeat --show-source --exclude=.venv,.tox,dist,doc,openstack,*egg .