clean up and get most test running
Remove extraneous utility code and tests. Skip tests related to remote object verification until we can rewrite them (see the adopt-oslo-versionedobjects spec for details). Fix pep8 errors. Update requirements. Set python's hash seed in tox.ini for tests that compare things that might come out in a different order.
This commit is contained in:
Doug Hellmann
parent
a053c473c3
commit
1e146a916e
|
|
@ -0,0 +1,35 @@
|
|||
# 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.
|
||||
|
||||
"""oslo.i18n integration module.
|
||||
|
||||
See http://docs.openstack.org/developer/oslo.i18n/usage.html
|
||||
|
||||
"""
|
||||
|
||||
import oslo_i18n
|
||||
|
||||
|
||||
_translators = oslo_i18n.TranslatorFactory(domain='oslo.versionedobjects')
|
||||
|
||||
# The primary translation function using the well-known name "_"
|
||||
_ = _translators.primary
|
||||
|
||||
# Translators for log levels.
|
||||
#
|
||||
# The abbreviated names are meant to reflect the usual use of a short
|
||||
# name like '_'. The "L" is for "log" and the other letter comes from
|
||||
# the level.
|
||||
_LI = _translators.log_info
|
||||
_LW = _translators.log_warning
|
||||
_LE = _translators.log_error
|
||||
_LC = _translators.log_critical
|
||||
|
|
@ -19,21 +19,20 @@ import contextlib
|
|||
import copy
|
||||
import datetime
|
||||
import functools
|
||||
import logging
|
||||
import traceback
|
||||
|
||||
import netaddr
|
||||
from oslo import messaging
|
||||
from oslo.utils import timeutils
|
||||
from oslo_context import context
|
||||
import oslo_messaging as messaging
|
||||
from oslo_utils import timeutils
|
||||
import six
|
||||
|
||||
from nova import context
|
||||
from nova import exception
|
||||
from nova.i18n import _, _LE
|
||||
from nova import objects
|
||||
from nova.objects import fields
|
||||
from nova.openstack.common import log as logging
|
||||
from nova.openstack.common import versionutils
|
||||
from nova import utils
|
||||
from oslo_versionedobjects._i18n import _, _LE
|
||||
from oslo_versionedobjects import exception
|
||||
from oslo_versionedobjects import fields
|
||||
from oslo_versionedobjects.openstack.common import versionutils
|
||||
from oslo_versionedobjects import utils
|
||||
|
||||
|
||||
LOG = logging.getLogger('object')
|
||||
|
|
@ -120,23 +119,29 @@ class NovaObjectMetaclass(type):
|
|||
if cls.VERSION == obj.VERSION:
|
||||
cls._obj_classes[obj_name][i] = cls
|
||||
# Update nova.objects with this newer class.
|
||||
setattr(objects, obj_name, cls)
|
||||
# FIXME(dhellmann): We can't store library state in
|
||||
# the application module.
|
||||
# setattr(objects, obj_name, cls)
|
||||
break
|
||||
if _vers_tuple(cls) > _vers_tuple(obj):
|
||||
# Insert before.
|
||||
cls._obj_classes[obj_name].insert(i, cls)
|
||||
if i == 0:
|
||||
# Later version than we've seen before. Update
|
||||
# nova.objects.
|
||||
setattr(objects, obj_name, cls)
|
||||
# FIXME(dhellmann): We can't store library state in
|
||||
# the application module.
|
||||
# if i == 0:
|
||||
# # Later version than we've seen before. Update
|
||||
# # nova.objects.
|
||||
# setattr(objects, obj_name, cls)
|
||||
break
|
||||
else:
|
||||
cls._obj_classes[obj_name].append(cls)
|
||||
# Either this is the first time we've seen the object or it's
|
||||
# an older version than anything we'e seen. Update nova.objects
|
||||
# only if it's the first time we've seen this object name.
|
||||
if not hasattr(objects, obj_name):
|
||||
setattr(objects, obj_name, cls)
|
||||
# FIXME(dhellmann): We can't store library state in
|
||||
# the application module.
|
||||
# if not hasattr(objects, obj_name):
|
||||
# setattr(objects, obj_name, cls)
|
||||
|
||||
|
||||
# These are decorators that mark an object's method as remotable.
|
||||
|
|
@ -615,7 +620,7 @@ class NovaObjectDictCompat(object):
|
|||
"""
|
||||
if key not in self.obj_fields:
|
||||
raise AttributeError("'%s' object has no attribute '%s'" % (
|
||||
self.__class__, key))
|
||||
self.__class__, key))
|
||||
if value != NotSpecifiedSentinel and not self.obj_attr_is_set(key):
|
||||
return value
|
||||
else:
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -17,11 +17,10 @@ import datetime
|
|||
|
||||
import iso8601
|
||||
import netaddr
|
||||
from oslo.utils import timeutils
|
||||
from oslo_utils import timeutils
|
||||
import six
|
||||
|
||||
from nova.i18n import _
|
||||
from nova.network import model as network_model
|
||||
from oslo_versionedobjects._i18n import _
|
||||
|
||||
|
||||
class KeyTypeError(TypeError):
|
||||
|
|
@ -386,7 +385,7 @@ class List(CompoundFieldType):
|
|||
raise ValueError(_('A list is required here'))
|
||||
for index, element in enumerate(list(value)):
|
||||
value[index] = self._element_type.coerce(
|
||||
obj, '%s[%i]' % (attr, index), element)
|
||||
obj, '%s[%i]' % (attr, index), element)
|
||||
return value
|
||||
|
||||
def to_primitive(self, obj, attr, value):
|
||||
|
|
@ -514,7 +513,7 @@ class Object(FieldType):
|
|||
@staticmethod
|
||||
def from_primitive(obj, attr, value):
|
||||
# FIXME(danms): Avoid circular import from base.py
|
||||
from nova.objects import base as obj_base
|
||||
from oslo_versionedobjects import base as obj_base
|
||||
# NOTE (ndipanov): If they already got hydrated by the serializer, just
|
||||
# pass them back unchanged
|
||||
if isinstance(value, obj_base.NovaObject):
|
||||
|
|
@ -537,30 +536,6 @@ class Object(FieldType):
|
|||
return '%s%s' % (self._obj_name, ident)
|
||||
|
||||
|
||||
class NetworkModel(FieldType):
|
||||
@staticmethod
|
||||
def coerce(obj, attr, value):
|
||||
if isinstance(value, network_model.NetworkInfo):
|
||||
return value
|
||||
elif isinstance(value, six.string_types):
|
||||
# Hmm, do we need this?
|
||||
return network_model.NetworkInfo.hydrate(value)
|
||||
else:
|
||||
raise ValueError(_('A NetworkModel is required here'))
|
||||
|
||||
@staticmethod
|
||||
def to_primitive(obj, attr, value):
|
||||
return value.json()
|
||||
|
||||
@staticmethod
|
||||
def from_primitive(obj, attr, value):
|
||||
return network_model.NetworkInfo.hydrate(value)
|
||||
|
||||
def stringify(self, value):
|
||||
return 'NetworkModel(%s)' % (
|
||||
','.join([str(vif['id']) for vif in value]))
|
||||
|
||||
|
||||
class AutoTypedField(Field):
|
||||
AUTO_TYPE = None
|
||||
|
||||
|
|
|
|||
|
|
@ -26,97 +26,47 @@ eventlet.monkey_patch(os=False)
|
|||
|
||||
import copy
|
||||
import inspect
|
||||
import logging
|
||||
import mock
|
||||
import os
|
||||
|
||||
import fixtures
|
||||
from oslo.config import cfg
|
||||
from oslo.config import fixture as config_fixture
|
||||
from oslo.utils import timeutils
|
||||
from oslo_concurrency import lockutils
|
||||
from oslo_config import cfg
|
||||
from oslo_config import fixture as config_fixture
|
||||
from oslo_log.fixture import logging_error
|
||||
import oslo_log.log as logging
|
||||
from oslo_utils import timeutils
|
||||
from oslotest import moxstubout
|
||||
import six
|
||||
import testtools
|
||||
|
||||
from nova import context
|
||||
from nova import db
|
||||
from nova.network import manager as network_manager
|
||||
from nova import objects
|
||||
from nova.objects import base as objects_base
|
||||
from nova.openstack.common.fixture import logging as log_fixture
|
||||
from nova.openstack.common import log as nova_logging
|
||||
from nova.tests import fixtures as nova_fixtures
|
||||
from nova.tests.unit import conf_fixture
|
||||
from nova.tests.unit import policy_fixture
|
||||
from nova import utils
|
||||
#from nova import db
|
||||
#from nova.network import manager as network_manager
|
||||
#from nova import objects
|
||||
from oslo_versionedobjects import base as objects_base
|
||||
from oslo_versionedobjects.tests import fixtures as nova_fixtures
|
||||
from oslo_versionedobjects import utils
|
||||
|
||||
|
||||
CONF = cfg.CONF
|
||||
CONF.import_opt('enabled', 'nova.api.openstack', group='osapi_v3')
|
||||
CONF.set_override('use_stderr', False)
|
||||
# CONF.import_opt('enabled', 'nova.api.openstack', group='osapi_v3')
|
||||
# CONF.set_override('use_stderr', False)
|
||||
|
||||
nova_logging.setup('nova')
|
||||
logging.register_options(CONF)
|
||||
logging.setup(CONF, 'nova')
|
||||
|
||||
# NOTE(comstud): Make sure we have all of the objects loaded. We do this
|
||||
# at module import time, because we may be using mock decorators in our
|
||||
# tests that run at import time.
|
||||
objects.register_all()
|
||||
|
||||
_TRUE_VALUES = ('True', 'true', '1', 'yes')
|
||||
|
||||
|
||||
class SampleNetworks(fixtures.Fixture):
|
||||
|
||||
"""Create sample networks in the database."""
|
||||
|
||||
def __init__(self, host=None):
|
||||
self.host = host
|
||||
|
||||
def setUp(self):
|
||||
super(SampleNetworks, self).setUp()
|
||||
ctxt = context.get_admin_context()
|
||||
network = network_manager.VlanManager(host=self.host)
|
||||
bridge_interface = CONF.flat_interface or CONF.vlan_interface
|
||||
network.create_networks(ctxt,
|
||||
label='test',
|
||||
cidr='10.0.0.0/8',
|
||||
multi_host=CONF.multi_host,
|
||||
num_networks=CONF.num_networks,
|
||||
network_size=CONF.network_size,
|
||||
cidr_v6=CONF.fixed_range_v6,
|
||||
gateway=CONF.gateway,
|
||||
gateway_v6=CONF.gateway_v6,
|
||||
bridge=CONF.flat_network_bridge,
|
||||
bridge_interface=bridge_interface,
|
||||
vpn_start=CONF.vpn_start,
|
||||
vlan_start=CONF.vlan_start,
|
||||
dns1=CONF.flat_network_dns)
|
||||
for net in db.network_get_all(ctxt):
|
||||
network.set_network_host(ctxt, net)
|
||||
# FIXME(dhellmann): We can't store library state in
|
||||
# the application module.
|
||||
# objects.register_all()
|
||||
|
||||
|
||||
class TestingException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class NullHandler(logging.Handler):
|
||||
"""custom default NullHandler to attempt to format the record.
|
||||
|
||||
Used in conjunction with
|
||||
log_fixture.get_logging_handle_error_fixture to detect formatting errors in
|
||||
debug level logs without saving the logs.
|
||||
"""
|
||||
def handle(self, record):
|
||||
self.format(record)
|
||||
|
||||
def emit(self, record):
|
||||
pass
|
||||
|
||||
def createLock(self):
|
||||
self.lock = None
|
||||
|
||||
|
||||
class skipIf(object):
|
||||
def __init__(self, condition, reason):
|
||||
self.condition = condition
|
||||
|
|
@ -193,7 +143,7 @@ class TestCase(testtools.TestCase):
|
|||
self.useFixture(fixtures.NestedTempfile())
|
||||
self.useFixture(fixtures.TempHomeDir())
|
||||
self.useFixture(nova_fixtures.TranslationFixture())
|
||||
self.useFixture(log_fixture.get_logging_handle_error_fixture())
|
||||
self.useFixture(logging_error.get_logging_handle_error_fixture())
|
||||
|
||||
self.useFixture(nova_fixtures.OutputStreamCapture())
|
||||
|
||||
|
|
@ -217,11 +167,11 @@ class TestCase(testtools.TestCase):
|
|||
self.fixture.config(lock_path=lock_path,
|
||||
group='oslo_concurrency')
|
||||
|
||||
self.useFixture(conf_fixture.ConfFixture(CONF))
|
||||
self.useFixture(nova_fixtures.RPCFixture('nova.test'))
|
||||
# self.useFixture(config_fixture.ConfFixture(CONF))
|
||||
# self.useFixture(nova_fixtures.RPCFixture('nova.test'))
|
||||
|
||||
if self.USES_DB:
|
||||
self.useFixture(nova_fixtures.Database())
|
||||
# if self.USES_DB:
|
||||
# self.useFixture(nova_fixtures.Database())
|
||||
|
||||
# NOTE(blk-u): WarningsFixture must be after the Database fixture
|
||||
# because sqlalchemy-migrate messes with the warnings filters.
|
||||
|
|
@ -245,7 +195,6 @@ class TestCase(testtools.TestCase):
|
|||
self.stubs = mox_fixture.stubs
|
||||
self.addCleanup(self._clear_attrs)
|
||||
self.useFixture(fixtures.EnvironmentVariable('http_proxy'))
|
||||
self.policy = self.useFixture(policy_fixture.PolicyFixture())
|
||||
|
||||
def _restore_obj_registry(self):
|
||||
objects_base.NovaObject._obj_classes = self._base_test_obj_backup
|
||||
|
|
|
|||
|
|
@ -24,13 +24,12 @@ import uuid
|
|||
import warnings
|
||||
|
||||
import fixtures
|
||||
from oslo.config import cfg
|
||||
from oslo.messaging import conffixture as messaging_conffixture
|
||||
from oslo_config import cfg
|
||||
|
||||
from nova.db import migration
|
||||
from nova.db.sqlalchemy import api as session
|
||||
from nova import rpc
|
||||
from nova import service
|
||||
# from nova.db import migration
|
||||
# from nova.db.sqlalchemy import api as session
|
||||
# from nova import rpc
|
||||
# from nova import service
|
||||
|
||||
_TRUE_VALUES = ('True', 'true', '1', 'yes')
|
||||
|
||||
|
|
@ -50,9 +49,11 @@ class ServiceFixture(fixtures.Fixture):
|
|||
|
||||
def setUp(self):
|
||||
super(ServiceFixture, self).setUp()
|
||||
self.service = service.Service.create(**self.kwargs)
|
||||
self.service.start()
|
||||
self.addCleanup(self.service.kill)
|
||||
# FIXME(dhellmann): See work items in
|
||||
# adopt-oslo-versionedobjects spec.
|
||||
# self.service = service.Service.create(**self.kwargs)
|
||||
# self.service.start()
|
||||
# self.addCleanup(self.service.kill)
|
||||
|
||||
|
||||
class TranslationFixture(fixtures.Fixture):
|
||||
|
|
@ -200,43 +201,43 @@ class Timeout(fixtures.Fixture):
|
|||
self.useFixture(fixtures.Timeout(self.test_timeout, gentle=True))
|
||||
|
||||
|
||||
class Database(fixtures.Fixture):
|
||||
def _cache_schema(self):
|
||||
global DB_SCHEMA
|
||||
if not DB_SCHEMA:
|
||||
engine = session.get_engine()
|
||||
conn = engine.connect()
|
||||
migration.db_sync()
|
||||
DB_SCHEMA = "".join(line for line in conn.connection.iterdump())
|
||||
engine.dispose()
|
||||
# class Database(fixtures.Fixture):
|
||||
# def _cache_schema(self):
|
||||
# global DB_SCHEMA
|
||||
# if not DB_SCHEMA:
|
||||
# engine = session.get_engine()
|
||||
# conn = engine.connect()
|
||||
# migration.db_sync()
|
||||
# DB_SCHEMA = "".join(line for line in conn.connection.iterdump())
|
||||
# engine.dispose()
|
||||
|
||||
def reset(self):
|
||||
self._cache_schema()
|
||||
engine = session.get_engine()
|
||||
engine.dispose()
|
||||
conn = engine.connect()
|
||||
conn.connection.executescript(DB_SCHEMA)
|
||||
# def reset(self):
|
||||
# self._cache_schema()
|
||||
# engine = session.get_engine()
|
||||
# engine.dispose()
|
||||
# conn = engine.connect()
|
||||
# conn.connection.executescript(DB_SCHEMA)
|
||||
|
||||
def setUp(self):
|
||||
super(Database, self).setUp()
|
||||
self.reset()
|
||||
# def setUp(self):
|
||||
# super(Database, self).setUp()
|
||||
# self.reset()
|
||||
|
||||
|
||||
class RPCFixture(fixtures.Fixture):
|
||||
def __init__(self, *exmods):
|
||||
super(RPCFixture, self).__init__()
|
||||
self.exmods = []
|
||||
self.exmods.extend(exmods)
|
||||
# class RPCFixture(fixtures.Fixture):
|
||||
# def __init__(self, *exmods):
|
||||
# super(RPCFixture, self).__init__()
|
||||
# self.exmods = []
|
||||
# self.exmods.extend(exmods)
|
||||
|
||||
def setUp(self):
|
||||
super(RPCFixture, self).setUp()
|
||||
self.addCleanup(rpc.cleanup)
|
||||
rpc.add_extra_exmods(*self.exmods)
|
||||
self.addCleanup(rpc.clear_extra_exmods)
|
||||
self.messaging_conf = messaging_conffixture.ConfFixture(CONF)
|
||||
self.messaging_conf.transport_driver = 'fake'
|
||||
self.useFixture(self.messaging_conf)
|
||||
rpc.init(CONF)
|
||||
# def setUp(self):
|
||||
# super(RPCFixture, self).setUp()
|
||||
# self.addCleanup(rpc.cleanup)
|
||||
# rpc.add_extra_exmods(*self.exmods)
|
||||
# self.addCleanup(rpc.clear_extra_exmods)
|
||||
# self.messaging_conf = messaging_conffixture.ConfFixture(CONF)
|
||||
# self.messaging_conf.transport_driver = 'fake'
|
||||
# self.useFixture(self.messaging_conf)
|
||||
# rpc.init(CONF)
|
||||
|
||||
|
||||
class WarningsFixture(fixtures.Fixture):
|
||||
|
|
|
|||
|
|
@ -16,12 +16,11 @@ import datetime
|
|||
|
||||
import iso8601
|
||||
import netaddr
|
||||
from oslo.utils import timeutils
|
||||
from oslo_utils import timeutils
|
||||
|
||||
from nova.network import model as network_model
|
||||
from nova.objects import base as obj_base
|
||||
from nova.objects import fields
|
||||
from nova import test
|
||||
from oslo_versionedobjects import base as obj_base
|
||||
from oslo_versionedobjects import fields
|
||||
from oslo_versionedobjects import test
|
||||
|
||||
|
||||
class FakeFieldType(fields.FieldType):
|
||||
|
|
@ -64,7 +63,7 @@ class TestField(test.NoDBTestCase):
|
|||
|
||||
for prim_val, out_val in self.from_primitive_values:
|
||||
self.assertEqual(out_val, self.field.from_primitive(
|
||||
ObjectLikeThing, 'attr', prim_val))
|
||||
ObjectLikeThing, 'attr', prim_val))
|
||||
|
||||
def test_stringify(self):
|
||||
self.assertEqual('123', self.field.stringify(123))
|
||||
|
|
@ -257,7 +256,7 @@ class TestListOfDictOfNullableStringsField(TestField):
|
|||
def test_stringify(self):
|
||||
self.assertEqual("[{f=None,f1='b1'},{f2='b2'}]",
|
||||
self.field.stringify(
|
||||
[{'f': None, 'f1': 'b1'}, {'f2': 'b2'}]))
|
||||
[{'f': None, 'f1': 'b1'}, {'f2': 'b2'}]))
|
||||
|
||||
|
||||
class TestList(TestField):
|
||||
|
|
@ -354,7 +353,7 @@ class TestObject(TestField):
|
|||
self.to_primitive_values = [(test_inst, test_inst.obj_to_primitive())]
|
||||
self.from_primitive_values = [(test_inst.obj_to_primitive(),
|
||||
test_inst),
|
||||
(test_inst, test_inst)]
|
||||
(test_inst, test_inst)]
|
||||
|
||||
def test_stringify(self):
|
||||
obj = self._test_cls(uuid='fake-uuid')
|
||||
|
|
@ -362,24 +361,6 @@ class TestObject(TestField):
|
|||
self.field.stringify(obj))
|
||||
|
||||
|
||||
class TestNetworkModel(TestField):
|
||||
def setUp(self):
|
||||
super(TestNetworkModel, self).setUp()
|
||||
model = network_model.NetworkInfo()
|
||||
self.field = fields.Field(fields.NetworkModel())
|
||||
self.coerce_good_values = [(model, model), (model.json(), model)]
|
||||
self.coerce_bad_values = [[], 'foo']
|
||||
self.to_primitive_values = [(model, model.json())]
|
||||
self.from_primitive_values = [(model.json(), model)]
|
||||
|
||||
def test_stringify(self):
|
||||
networkinfo = network_model.NetworkInfo()
|
||||
networkinfo.append(network_model.VIF(id=123))
|
||||
networkinfo.append(network_model.VIF(id=456))
|
||||
self.assertEqual('NetworkModel(123,456)',
|
||||
self.field.stringify(networkinfo))
|
||||
|
||||
|
||||
class TestIPNetwork(TestField):
|
||||
def setUp(self):
|
||||
super(TestIPNetwork, self).setUp()
|
||||
|
|
|
|||
|
|
@ -17,29 +17,28 @@ import copy
|
|||
import datetime
|
||||
import hashlib
|
||||
import inspect
|
||||
import logging
|
||||
import os
|
||||
import pprint
|
||||
|
||||
import mock
|
||||
from oslo.serialization import jsonutils
|
||||
from oslo.utils import timeutils
|
||||
from oslo_context import context
|
||||
from oslo_serialization import jsonutils
|
||||
from oslo_utils import timeutils
|
||||
import six
|
||||
from testtools import matchers
|
||||
|
||||
from nova.conductor import rpcapi as conductor_rpcapi
|
||||
from nova import context
|
||||
from nova import exception
|
||||
from nova import objects
|
||||
from nova.objects import base
|
||||
from nova.objects import fields
|
||||
from nova.openstack.common import log
|
||||
from nova import rpc
|
||||
from nova import test
|
||||
from nova.tests.unit import fake_notifier
|
||||
from nova import utils
|
||||
# from nova.conductor import rpcapi as conductor_rpcapi
|
||||
from oslo_versionedobjects import base
|
||||
from oslo_versionedobjects import exception
|
||||
from oslo_versionedobjects import fields
|
||||
# from nova import rpc
|
||||
from oslo_versionedobjects import test
|
||||
# from nova.tests.unit import fake_notifier
|
||||
from oslo_versionedobjects import utils
|
||||
|
||||
|
||||
LOG = log.getLogger(__name__)
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class MyOwnedObject(base.NovaPersistentObject, base.NovaObject):
|
||||
|
|
@ -83,7 +82,10 @@ class MyObj(base.NovaPersistentObject, base.NovaObject,
|
|||
|
||||
@base.remotable
|
||||
def _update_test(self, context):
|
||||
if context.project_id == 'alternate':
|
||||
project_id = getattr(context, 'tenant', None)
|
||||
if project_id is None:
|
||||
project_id = getattr(context, 'project_id', None)
|
||||
if project_id == 'alternate':
|
||||
self.bar = 'alternate-context'
|
||||
else:
|
||||
self.bar = 'updated'
|
||||
|
|
@ -311,8 +313,10 @@ class _BaseTestCase(test.TestCase):
|
|||
self.user_id = 'fake-user'
|
||||
self.project_id = 'fake-project'
|
||||
self.context = context.RequestContext(self.user_id, self.project_id)
|
||||
fake_notifier.stub_notifier(self.stubs)
|
||||
self.addCleanup(fake_notifier.reset)
|
||||
# FIXME(dhellmann): See work items in
|
||||
# adopt-oslo-versionedobjects spec.
|
||||
# fake_notifier.stub_notifier(self.stubs)
|
||||
# self.addCleanup(fake_notifier.reset)
|
||||
|
||||
def compare_obj(self, obj, db_obj, subs=None, allow_missing=None,
|
||||
comparators=None):
|
||||
|
|
@ -393,17 +397,21 @@ class _RemoteTest(_BaseTestCase):
|
|||
fake_object_action)
|
||||
|
||||
# Things are remoted by default in this session
|
||||
base.NovaObject.indirection_api = conductor_rpcapi.ConductorAPI()
|
||||
# FIXME(dhellmann): See work items in adopt-oslo-versionedobjects.
|
||||
# base.NovaObject.indirection_api = conductor_rpcapi.ConductorAPI()
|
||||
|
||||
# To make sure local and remote contexts match
|
||||
self.stubs.Set(rpc.RequestContextSerializer,
|
||||
'serialize_context',
|
||||
lambda s, c: c)
|
||||
self.stubs.Set(rpc.RequestContextSerializer,
|
||||
'deserialize_context',
|
||||
lambda s, c: c)
|
||||
# FIXME(dhellmann): See work items in adopt-oslo-versionedobjects.
|
||||
# self.stubs.Set(rpc.RequestContextSerializer,
|
||||
# 'serialize_context',
|
||||
# lambda s, c: c)
|
||||
# self.stubs.Set(rpc.RequestContextSerializer,
|
||||
# 'deserialize_context',
|
||||
# lambda s, c: c)
|
||||
|
||||
def setUp(self):
|
||||
# FIXME(dhellmann): See work items in adopt-oslo-versionedobjects.
|
||||
self.skip('remote tests need to be rewritten')
|
||||
super(_RemoteTest, self).setUp()
|
||||
self._testable_conductor()
|
||||
|
||||
|
|
@ -412,13 +420,13 @@ class _RemoteTest(_BaseTestCase):
|
|||
|
||||
|
||||
class _TestObject(object):
|
||||
def test_object_attrs_in_init(self):
|
||||
# Spot check a few
|
||||
objects.Instance
|
||||
objects.InstanceInfoCache
|
||||
objects.SecurityGroup
|
||||
# Now check the test one in this file. Should be newest version
|
||||
self.assertEqual('1.6', objects.MyObj.VERSION)
|
||||
# def test_object_attrs_in_init(self):
|
||||
# # Spot check a few
|
||||
# objects.Instance
|
||||
# objects.InstanceInfoCache
|
||||
# objects.SecurityGroup
|
||||
# # Now check the test one in this file. Should be newest version
|
||||
# self.assertEqual('1.6', objects.MyObj.VERSION)
|
||||
|
||||
def test_hydration_type_error(self):
|
||||
primitive = {'nova_object.name': 'MyObj',
|
||||
|
|
@ -561,8 +569,8 @@ class _TestObject(object):
|
|||
self.assertEqual('1.6', error.kwargs['supported'])
|
||||
|
||||
def test_with_alternate_context(self):
|
||||
ctxt1 = context.RequestContext('foo', 'foo')
|
||||
ctxt2 = context.RequestContext('bar', 'alternate')
|
||||
ctxt1 = context.RequestContext(None, 'foo', 'foo')
|
||||
ctxt2 = context.RequestContext(None, 'bar', 'alternate')
|
||||
obj = MyObj.query(ctxt1)
|
||||
obj._update_test(ctxt2)
|
||||
self.assertEqual(obj.bar, 'alternate-context')
|
||||
|
|
@ -649,18 +657,20 @@ class _TestObject(object):
|
|||
dt = datetime.datetime(1955, 11, 5)
|
||||
obj = MyObj(created_at=dt, updated_at=dt, deleted_at=None,
|
||||
deleted=False)
|
||||
expected = {'nova_object.name': 'MyObj',
|
||||
'nova_object.namespace': 'nova',
|
||||
'nova_object.version': '1.6',
|
||||
'nova_object.changes':
|
||||
['deleted', 'created_at', 'deleted_at', 'updated_at'],
|
||||
'nova_object.data':
|
||||
{'created_at': timeutils.isotime(dt),
|
||||
'updated_at': timeutils.isotime(dt),
|
||||
'deleted_at': None,
|
||||
'deleted': False,
|
||||
}
|
||||
}
|
||||
expected = {
|
||||
'nova_object.name': 'MyObj',
|
||||
'nova_object.namespace': 'nova',
|
||||
'nova_object.version': '1.6',
|
||||
'nova_object.changes': [
|
||||
'deleted', 'created_at', 'deleted_at', 'updated_at',
|
||||
],
|
||||
'nova_object.data': {
|
||||
'created_at': timeutils.isotime(dt),
|
||||
'updated_at': timeutils.isotime(dt),
|
||||
'deleted_at': None,
|
||||
'deleted': False,
|
||||
},
|
||||
}
|
||||
self.assertEqual(obj.obj_to_primitive(), expected)
|
||||
|
||||
def test_contains(self):
|
||||
|
|
@ -708,6 +718,7 @@ class _TestObject(object):
|
|||
set(TestSubclassedObject.fields.keys()))
|
||||
|
||||
def test_obj_as_admin(self):
|
||||
self.skip('oslo.context does not support elevated()')
|
||||
obj = MyObj(context=self.context)
|
||||
|
||||
def fake(*args, **kwargs):
|
||||
|
|
@ -1113,76 +1124,9 @@ class TestObjectSerializer(_BaseTestCase):
|
|||
# they come with a corresponding version bump in the affected
|
||||
# objects
|
||||
object_data = {
|
||||
'Agent': '1.0-c4ff8a833aee8ae44ab8aed1a171273d',
|
||||
'AgentList': '1.0-31f07426a729311a42ff7f6246e76e25',
|
||||
'Aggregate': '1.1-f5d477be06150529a9b2d27cc49030b5',
|
||||
'AggregateList': '1.2-4b02a285b8612bfb86a96ff80052fb0a',
|
||||
'BandwidthUsage': '1.2-a9d7c2ba54995e48ce38688c51c9416d',
|
||||
'BandwidthUsageList': '1.2-5b564cbfd5ae6e106443c086938e7602',
|
||||
'BlockDeviceMapping': '1.6-9968ffe513e7672484b0f528b034cd0f',
|
||||
'BlockDeviceMappingList': '1.7-b67dc6a04cff2cdb53e6f25e146da456',
|
||||
'ComputeNode': '1.10-70202a38b858977837b313d94475a26b',
|
||||
'ComputeNodeList': '1.10-4ae1f844c247029fbcdb5fdccbe9e619',
|
||||
'DNSDomain': '1.0-5bdc288d7c3b723ce86ede998fd5c9ba',
|
||||
'DNSDomainList': '1.0-cfb3e7e82be661501c31099523154db4',
|
||||
'EC2InstanceMapping': '1.0-627baaf4b12c9067200979bdc4558a99',
|
||||
'EC2SnapshotMapping': '1.0-26cf315be1f8abab4289d4147671c836',
|
||||
'EC2VolumeMapping': '1.0-2f8c3bf077c65a425294ec2b361c9143',
|
||||
'FixedIP': '1.8-2472964d39e50da67202109eb85cd173',
|
||||
'FixedIPList': '1.8-6cfaa5b6dd27e9eb8fcf8462dea06077',
|
||||
'Flavor': '1.1-096cfd023c35d07542cf732fb29b45e4',
|
||||
'FlavorList': '1.1-a3d5551267cb8f62ff38ded125900721',
|
||||
'FloatingIP': '1.6-27eb68b7c9c620dd5f0561b5a3be0e82',
|
||||
'FloatingIPList': '1.7-f376f63ed99243f9d90841b7f6732bbf',
|
||||
'HVSpec': '1.0-c4d8377cc4fe519930e60c1d8265a142',
|
||||
'Instance': '1.18-7827a9e9846a75f3038bd556e6f530d3',
|
||||
'InstanceAction': '1.1-6b1d0a6dbd522b5a83c20757ec659663',
|
||||
'InstanceActionEvent': '1.1-42dbdba74bd06e0619ca75cd3397cd1b',
|
||||
'InstanceActionEventList': '1.0-1d5cc958171d6ce07383c2ad6208318e',
|
||||
'InstanceActionList': '1.0-368410fdb8d69ae20c495308535d6266',
|
||||
'InstanceExternalEvent': '1.0-f1134523654407a875fd59b80f759ee7',
|
||||
'InstanceFault': '1.2-313438e37e9d358f3566c85f6ddb2d3e',
|
||||
'InstanceFaultList': '1.1-aeb598ffd0cd6aa61fca7adf0f5e900d',
|
||||
'InstanceGroup': '1.9-95ece99f092e8f4f88327cdbb44162c9',
|
||||
'InstanceGroupList': '1.6-c6b78f3c9d9080d33c08667e80589817',
|
||||
'InstanceInfoCache': '1.5-ef64b604498bfa505a8c93747a9d8b2f',
|
||||
'InstanceList': '1.14-fe7f3266de1475454b939dee36a2ebcc',
|
||||
'InstanceNUMACell': '1.2-5d2dfa36e9ecca9b63f24bf3bc958ea4',
|
||||
'InstanceNUMATopology': '1.1-86b95d263c4c68411d44c6741b8d2bb0',
|
||||
'InstancePCIRequest': '1.1-e082d174f4643e5756ba098c47c1510f',
|
||||
'InstancePCIRequests': '1.1-bc7c6684d8579ee49d6a3b8aef756918',
|
||||
'KeyPair': '1.1-3410f51950d052d861c11946a6ae621a',
|
||||
'KeyPairList': '1.0-71132a568cc5d078ba1748a9c02c87b8',
|
||||
'Migration': '1.1-67c47726c2c71422058cd9d149d6d3ed',
|
||||
'MigrationList': '1.1-8c5f678edc72a592d591a13b35e54353',
|
||||
'MyObj': '1.6-02b1e712b7ee334fa3fefe024c340977',
|
||||
'MyOwnedObject': '1.0-0f3d6c028543d7f3715d121db5b8e298',
|
||||
'Network': '1.2-2ea21ede5e45bb80e7b7ac7106915c4e',
|
||||
'NetworkList': '1.2-aa4ad23f035b97a41732ea8b3445fc5e',
|
||||
'NetworkRequest': '1.1-f31192f5a725017707f989585e12d7dc',
|
||||
'NetworkRequestList': '1.1-beeab521ac9450f1f5ef4eaa945a783c',
|
||||
'NUMACell': '1.2-cb9c3b08cc1c418d021492f788d04173',
|
||||
'NUMAPagesTopology': '1.0-97d93f70a68625b5f29ff63a40a4f612',
|
||||
'NUMATopology': '1.2-790f6bdff85bf6e5677f409f3a4f1c6a',
|
||||
'PciDevice': '1.3-e059641df10e85d464672c5183a9473b',
|
||||
'PciDeviceList': '1.1-38cbe2d3c23b9e46f7a74b486abcad85',
|
||||
'PciDevicePool': '1.0-d6ed1abe611c9947345a44155abe6f11',
|
||||
'PciDevicePoolList': '1.0-d31e08e0ff620a4df7cc2014b6c50da8',
|
||||
'Quotas': '1.2-36098cf2143e6535873c3fa3d6fe56f7',
|
||||
'QuotasNoOp': '1.2-164c628906b170fd946a7672e85e4935',
|
||||
'S3ImageMapping': '1.0-9225943a44a91ad0349b9fd8bd3f3ce2',
|
||||
'SecurityGroup': '1.1-bba0e72865e0953793e796571692453b',
|
||||
'SecurityGroupList': '1.0-528e6448adfeeb78921ebeda499ab72f',
|
||||
'SecurityGroupRule': '1.1-a9175baf7664439af1a16c2010b55576',
|
||||
'SecurityGroupRuleList': '1.1-667fca3a9928f23d2d10e61962c55f3c',
|
||||
'Service': '1.9-82bbfd46a744a9c89bc44b47a1b81683',
|
||||
'ServiceList': '1.7-b856301eb7714839248e189bf4886168',
|
||||
'Tag': '1.0-a11531f4e4e3166eef6243d6d58a18bd',
|
||||
'TagList': '1.0-e89bf8c8055f1f1d654fb44f0abf1f53',
|
||||
'TestSubclassedObject': '1.6-87177ccbefd7a740a9e261f958e15b00',
|
||||
'VirtualInterface': '1.0-10fdac4c704102b6d57d6936d6d790d2',
|
||||
'VirtualInterfaceList': '1.0-accbf02628a8063c1d885077a2bf49b6',
|
||||
'VirtCPUTopology': '1.0-fc694de72e20298f7c6bab1083fd4563',
|
||||
'MyObj': '1.6-b733cfefd8dcf706843d6bce5cd1be22',
|
||||
'MyOwnedObject': '1.0-fec853730bd02d54cc32771dd67f08a0',
|
||||
'TestSubclassedObject': '1.6-6c1976a36987b9832b3183a7d9163655',
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1289,6 +1233,7 @@ class TestObjectVersions(test.TestCase):
|
|||
tree[obj_name][sub_obj_name] = sub_obj_class.VERSION
|
||||
|
||||
def test_relationships(self):
|
||||
self.skip('relationship test needs to be rewritten')
|
||||
tree = {}
|
||||
for obj_name in base.NovaObject._obj_classes.keys():
|
||||
self._build_tree(tree, base.NovaObject._obj_classes[obj_name][0])
|
||||
|
|
|
|||
|
|
@ -12,852 +12,15 @@
|
|||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
import datetime
|
||||
import functools
|
||||
import hashlib
|
||||
import importlib
|
||||
import os
|
||||
import os.path
|
||||
import StringIO
|
||||
import tempfile
|
||||
from oslo_config import cfg
|
||||
|
||||
import mock
|
||||
from mox3 import mox
|
||||
import netaddr
|
||||
from oslo.config import cfg
|
||||
from oslo.utils import timeutils
|
||||
from oslo_concurrency import processutils
|
||||
|
||||
import nova
|
||||
from nova import exception
|
||||
from nova import test
|
||||
from nova import utils
|
||||
from oslo_versionedobjects import exception
|
||||
from oslo_versionedobjects import test
|
||||
from oslo_versionedobjects import utils
|
||||
|
||||
CONF = cfg.CONF
|
||||
|
||||
|
||||
class GenericUtilsTestCase(test.NoDBTestCase):
|
||||
def test_parse_server_string(self):
|
||||
result = utils.parse_server_string('::1')
|
||||
self.assertEqual(('::1', ''), result)
|
||||
result = utils.parse_server_string('[::1]:8773')
|
||||
self.assertEqual(('::1', '8773'), result)
|
||||
result = utils.parse_server_string('2001:db8::192.168.1.1')
|
||||
self.assertEqual(('2001:db8::192.168.1.1', ''), result)
|
||||
result = utils.parse_server_string('[2001:db8::192.168.1.1]:8773')
|
||||
self.assertEqual(('2001:db8::192.168.1.1', '8773'), result)
|
||||
result = utils.parse_server_string('192.168.1.1')
|
||||
self.assertEqual(('192.168.1.1', ''), result)
|
||||
result = utils.parse_server_string('192.168.1.2:8773')
|
||||
self.assertEqual(('192.168.1.2', '8773'), result)
|
||||
result = utils.parse_server_string('192.168.1.3')
|
||||
self.assertEqual(('192.168.1.3', ''), result)
|
||||
result = utils.parse_server_string('www.example.com:8443')
|
||||
self.assertEqual(('www.example.com', '8443'), result)
|
||||
result = utils.parse_server_string('www.example.com')
|
||||
self.assertEqual(('www.example.com', ''), result)
|
||||
# error case
|
||||
result = utils.parse_server_string('www.exa:mple.com:8443')
|
||||
self.assertEqual(('', ''), result)
|
||||
result = utils.parse_server_string('')
|
||||
self.assertEqual(('', ''), result)
|
||||
|
||||
def test_hostname_unicode_sanitization(self):
|
||||
hostname = u"\u7684.test.example.com"
|
||||
self.assertEqual("test.example.com",
|
||||
utils.sanitize_hostname(hostname))
|
||||
|
||||
def test_hostname_sanitize_periods(self):
|
||||
hostname = "....test.example.com..."
|
||||
self.assertEqual("test.example.com",
|
||||
utils.sanitize_hostname(hostname))
|
||||
|
||||
def test_hostname_sanitize_dashes(self):
|
||||
hostname = "----test.example.com---"
|
||||
self.assertEqual("test.example.com",
|
||||
utils.sanitize_hostname(hostname))
|
||||
|
||||
def test_hostname_sanitize_characters(self):
|
||||
hostname = "(#@&$!(@*--#&91)(__=+--test-host.example!!.com-0+"
|
||||
self.assertEqual("91----test-host.example.com-0",
|
||||
utils.sanitize_hostname(hostname))
|
||||
|
||||
def test_hostname_translate(self):
|
||||
hostname = "<}\x1fh\x10e\x08l\x02l\x05o\x12!{>"
|
||||
self.assertEqual("hello", utils.sanitize_hostname(hostname))
|
||||
|
||||
def test_read_cached_file(self):
|
||||
self.mox.StubOutWithMock(os.path, "getmtime")
|
||||
os.path.getmtime(mox.IgnoreArg()).AndReturn(1)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
cache_data = {"data": 1123, "mtime": 1}
|
||||
data = utils.read_cached_file("/this/is/a/fake", cache_data)
|
||||
self.assertEqual(cache_data["data"], data)
|
||||
|
||||
def test_read_modified_cached_file(self):
|
||||
self.mox.StubOutWithMock(os.path, "getmtime")
|
||||
os.path.getmtime(mox.IgnoreArg()).AndReturn(2)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
fake_contents = "lorem ipsum"
|
||||
m = mock.mock_open(read_data=fake_contents)
|
||||
with mock.patch("__builtin__.open", m, create=True):
|
||||
cache_data = {"data": 1123, "mtime": 1}
|
||||
self.reload_called = False
|
||||
|
||||
def test_reload(reloaded_data):
|
||||
self.assertEqual(reloaded_data, fake_contents)
|
||||
self.reload_called = True
|
||||
|
||||
data = utils.read_cached_file("/this/is/a/fake", cache_data,
|
||||
reload_func=test_reload)
|
||||
self.assertEqual(data, fake_contents)
|
||||
self.assertTrue(self.reload_called)
|
||||
|
||||
def test_generate_password(self):
|
||||
password = utils.generate_password()
|
||||
self.assertTrue([c for c in password if c in '0123456789'])
|
||||
self.assertTrue([c for c in password
|
||||
if c in 'abcdefghijklmnopqrstuvwxyz'])
|
||||
self.assertTrue([c for c in password
|
||||
if c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'])
|
||||
|
||||
def test_read_file_as_root(self):
|
||||
def fake_execute(*args, **kwargs):
|
||||
if args[1] == 'bad':
|
||||
raise processutils.ProcessExecutionError()
|
||||
return 'fakecontents', None
|
||||
|
||||
self.stubs.Set(utils, 'execute', fake_execute)
|
||||
contents = utils.read_file_as_root('good')
|
||||
self.assertEqual(contents, 'fakecontents')
|
||||
self.assertRaises(exception.FileNotFound,
|
||||
utils.read_file_as_root, 'bad')
|
||||
|
||||
def test_temporary_chown(self):
|
||||
def fake_execute(*args, **kwargs):
|
||||
if args[0] == 'chown':
|
||||
fake_execute.uid = args[1]
|
||||
self.stubs.Set(utils, 'execute', fake_execute)
|
||||
|
||||
with tempfile.NamedTemporaryFile() as f:
|
||||
with utils.temporary_chown(f.name, owner_uid=2):
|
||||
self.assertEqual(fake_execute.uid, 2)
|
||||
self.assertEqual(fake_execute.uid, os.getuid())
|
||||
|
||||
def test_xhtml_escape(self):
|
||||
self.assertEqual('"foo"', utils.xhtml_escape('"foo"'))
|
||||
self.assertEqual(''foo'', utils.xhtml_escape("'foo'"))
|
||||
self.assertEqual('&', utils.xhtml_escape('&'))
|
||||
self.assertEqual('>', utils.xhtml_escape('>'))
|
||||
self.assertEqual('<', utils.xhtml_escape('<'))
|
||||
self.assertEqual('<foo>', utils.xhtml_escape('<foo>'))
|
||||
|
||||
def test_is_valid_ipv6_cidr(self):
|
||||
self.assertTrue(utils.is_valid_ipv6_cidr("2600::/64"))
|
||||
self.assertTrue(utils.is_valid_ipv6_cidr(
|
||||
"abcd:ef01:2345:6789:abcd:ef01:192.168.254.254/48"))
|
||||
self.assertTrue(utils.is_valid_ipv6_cidr(
|
||||
"0000:0000:0000:0000:0000:0000:0000:0001/32"))
|
||||
self.assertTrue(utils.is_valid_ipv6_cidr(
|
||||
"0000:0000:0000:0000:0000:0000:0000:0001"))
|
||||
self.assertFalse(utils.is_valid_ipv6_cidr("foo"))
|
||||
self.assertFalse(utils.is_valid_ipv6_cidr("127.0.0.1"))
|
||||
|
||||
def test_get_shortened_ipv6(self):
|
||||
self.assertEqual("abcd:ef01:2345:6789:abcd:ef01:c0a8:fefe",
|
||||
utils.get_shortened_ipv6(
|
||||
"abcd:ef01:2345:6789:abcd:ef01:192.168.254.254"))
|
||||
self.assertEqual("::1", utils.get_shortened_ipv6(
|
||||
"0000:0000:0000:0000:0000:0000:0000:0001"))
|
||||
self.assertEqual("caca::caca:0:babe:201:102",
|
||||
utils.get_shortened_ipv6(
|
||||
"caca:0000:0000:caca:0000:babe:0201:0102"))
|
||||
self.assertRaises(netaddr.AddrFormatError, utils.get_shortened_ipv6,
|
||||
"127.0.0.1")
|
||||
self.assertRaises(netaddr.AddrFormatError, utils.get_shortened_ipv6,
|
||||
"failure")
|
||||
|
||||
def test_get_shortened_ipv6_cidr(self):
|
||||
self.assertEqual("2600::/64", utils.get_shortened_ipv6_cidr(
|
||||
"2600:0000:0000:0000:0000:0000:0000:0000/64"))
|
||||
self.assertEqual("2600::/64", utils.get_shortened_ipv6_cidr(
|
||||
"2600::1/64"))
|
||||
self.assertRaises(netaddr.AddrFormatError,
|
||||
utils.get_shortened_ipv6_cidr,
|
||||
"127.0.0.1")
|
||||
self.assertRaises(netaddr.AddrFormatError,
|
||||
utils.get_shortened_ipv6_cidr,
|
||||
"failure")
|
||||
|
||||
def test_get_hash_str(self):
|
||||
base_str = "foo"
|
||||
value = hashlib.md5(base_str).hexdigest()
|
||||
self.assertEqual(
|
||||
value, utils.get_hash_str(base_str))
|
||||
|
||||
def test_use_rootwrap(self):
|
||||
self.flags(disable_rootwrap=False, group='workarounds')
|
||||
self.flags(rootwrap_config='foo')
|
||||
cmd = utils._get_root_helper()
|
||||
self.assertEqual('sudo nova-rootwrap foo', cmd)
|
||||
|
||||
def test_use_sudo(self):
|
||||
self.flags(disable_rootwrap=True, group='workarounds')
|
||||
cmd = utils._get_root_helper()
|
||||
self.assertEqual('sudo', cmd)
|
||||
|
||||
|
||||
class MonkeyPatchTestCase(test.NoDBTestCase):
|
||||
"""Unit test for utils.monkey_patch()."""
|
||||
def setUp(self):
|
||||
super(MonkeyPatchTestCase, self).setUp()
|
||||
self.example_package = 'nova.tests.unit.monkey_patch_example.'
|
||||
self.flags(
|
||||
monkey_patch=True,
|
||||
monkey_patch_modules=[self.example_package + 'example_a' + ':'
|
||||
+ self.example_package + 'example_decorator'])
|
||||
|
||||
def test_monkey_patch(self):
|
||||
utils.monkey_patch()
|
||||
nova.tests.unit.monkey_patch_example.CALLED_FUNCTION = []
|
||||
from nova.tests.unit.monkey_patch_example import example_a
|
||||
from nova.tests.unit.monkey_patch_example import example_b
|
||||
|
||||
self.assertEqual('Example function', example_a.example_function_a())
|
||||
exampleA = example_a.ExampleClassA()
|
||||
exampleA.example_method()
|
||||
ret_a = exampleA.example_method_add(3, 5)
|
||||
self.assertEqual(ret_a, 8)
|
||||
|
||||
self.assertEqual('Example function', example_b.example_function_b())
|
||||
exampleB = example_b.ExampleClassB()
|
||||
exampleB.example_method()
|
||||
ret_b = exampleB.example_method_add(3, 5)
|
||||
|
||||
self.assertEqual(ret_b, 8)
|
||||
package_a = self.example_package + 'example_a.'
|
||||
self.assertIn(package_a + 'example_function_a',
|
||||
nova.tests.unit.monkey_patch_example.CALLED_FUNCTION)
|
||||
|
||||
self.assertIn(package_a + 'ExampleClassA.example_method',
|
||||
nova.tests.unit.monkey_patch_example.CALLED_FUNCTION)
|
||||
self.assertIn(package_a + 'ExampleClassA.example_method_add',
|
||||
nova.tests.unit.monkey_patch_example.CALLED_FUNCTION)
|
||||
package_b = self.example_package + 'example_b.'
|
||||
self.assertNotIn(package_b + 'example_function_b',
|
||||
nova.tests.unit.monkey_patch_example.CALLED_FUNCTION)
|
||||
self.assertNotIn(package_b + 'ExampleClassB.example_method',
|
||||
nova.tests.unit.monkey_patch_example.CALLED_FUNCTION)
|
||||
self.assertNotIn(package_b + 'ExampleClassB.example_method_add',
|
||||
nova.tests.unit.monkey_patch_example.CALLED_FUNCTION)
|
||||
|
||||
|
||||
class MonkeyPatchDefaultTestCase(test.NoDBTestCase):
|
||||
"""Unit test for default monkey_patch_modules value."""
|
||||
|
||||
def setUp(self):
|
||||
super(MonkeyPatchDefaultTestCase, self).setUp()
|
||||
self.flags(
|
||||
monkey_patch=True)
|
||||
|
||||
def test_monkey_patch_default_mod(self):
|
||||
# monkey_patch_modules is defined to be
|
||||
# <module_to_patch>:<decorator_to_patch_with>
|
||||
# Here we check that both parts of the default values are
|
||||
# valid
|
||||
for module in CONF.monkey_patch_modules:
|
||||
m = module.split(':', 1)
|
||||
# Check we can import the module to be patched
|
||||
importlib.import_module(m[0])
|
||||
# check the decorator is valid
|
||||
decorator_name = m[1].rsplit('.', 1)
|
||||
decorator_module = importlib.import_module(decorator_name[0])
|
||||
getattr(decorator_module, decorator_name[1])
|
||||
|
||||
|
||||
class AuditPeriodTest(test.NoDBTestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(AuditPeriodTest, self).setUp()
|
||||
# a fairly random time to test with
|
||||
self.test_time = datetime.datetime(second=23,
|
||||
minute=12,
|
||||
hour=8,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012)
|
||||
timeutils.set_time_override(override_time=self.test_time)
|
||||
|
||||
def tearDown(self):
|
||||
timeutils.clear_time_override()
|
||||
super(AuditPeriodTest, self).tearDown()
|
||||
|
||||
def test_hour(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='hour')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
hour=7,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
hour=8,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_hour_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='hour@10')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
minute=10,
|
||||
hour=7,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
minute=10,
|
||||
hour=8,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_hour_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='hour@30')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
minute=30,
|
||||
hour=6,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
minute=30,
|
||||
hour=7,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_day(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='day')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=4,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_day_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='day@6')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
hour=6,
|
||||
day=4,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
hour=6,
|
||||
day=5,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_day_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='day@10')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
hour=10,
|
||||
day=3,
|
||||
month=3,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
hour=10,
|
||||
day=4,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_month(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='month')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=2,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_month_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='month@2')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=2,
|
||||
month=2,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=2,
|
||||
month=3,
|
||||
year=2012))
|
||||
|
||||
def test_month_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='month@15')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=15,
|
||||
month=1,
|
||||
year=2012))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=15,
|
||||
month=2,
|
||||
year=2012))
|
||||
|
||||
def test_year(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='year')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=1,
|
||||
year=2011))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=1,
|
||||
year=2012))
|
||||
|
||||
def test_year_with_offset_before_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='year@2')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=2,
|
||||
year=2011))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=2,
|
||||
year=2012))
|
||||
|
||||
def test_year_with_offset_after_current(self):
|
||||
begin, end = utils.last_completed_audit_period(unit='year@6')
|
||||
self.assertEqual(begin, datetime.datetime(
|
||||
day=1,
|
||||
month=6,
|
||||
year=2010))
|
||||
self.assertEqual(end, datetime.datetime(
|
||||
day=1,
|
||||
month=6,
|
||||
year=2011))
|
||||
|
||||
|
||||
class MkfsTestCase(test.NoDBTestCase):
|
||||
|
||||
def test_mkfs(self):
|
||||
self.mox.StubOutWithMock(utils, 'execute')
|
||||
utils.execute('mkfs', '-t', 'ext4', '-F', '/my/block/dev',
|
||||
run_as_root=False)
|
||||
utils.execute('mkfs', '-t', 'msdos', '/my/msdos/block/dev',
|
||||
run_as_root=False)
|
||||
utils.execute('mkswap', '/my/swap/block/dev',
|
||||
run_as_root=False)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
utils.mkfs('ext4', '/my/block/dev')
|
||||
utils.mkfs('msdos', '/my/msdos/block/dev')
|
||||
utils.mkfs('swap', '/my/swap/block/dev')
|
||||
|
||||
def test_mkfs_with_label(self):
|
||||
self.mox.StubOutWithMock(utils, 'execute')
|
||||
utils.execute('mkfs', '-t', 'ext4', '-F',
|
||||
'-L', 'ext4-vol', '/my/block/dev', run_as_root=False)
|
||||
utils.execute('mkfs', '-t', 'msdos',
|
||||
'-n', 'msdos-vol', '/my/msdos/block/dev',
|
||||
run_as_root=False)
|
||||
utils.execute('mkswap', '-L', 'swap-vol', '/my/swap/block/dev',
|
||||
run_as_root=False)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
utils.mkfs('ext4', '/my/block/dev', 'ext4-vol')
|
||||
utils.mkfs('msdos', '/my/msdos/block/dev', 'msdos-vol')
|
||||
utils.mkfs('swap', '/my/swap/block/dev', 'swap-vol')
|
||||
|
||||
|
||||
class LastBytesTestCase(test.NoDBTestCase):
|
||||
"""Test the last_bytes() utility method."""
|
||||
|
||||
def setUp(self):
|
||||
super(LastBytesTestCase, self).setUp()
|
||||
self.f = StringIO.StringIO('1234567890')
|
||||
|
||||
def test_truncated(self):
|
||||
self.f.seek(0, os.SEEK_SET)
|
||||
out, remaining = utils.last_bytes(self.f, 5)
|
||||
self.assertEqual(out, '67890')
|
||||
self.assertTrue(remaining > 0)
|
||||
|
||||
def test_read_all(self):
|
||||
self.f.seek(0, os.SEEK_SET)
|
||||
out, remaining = utils.last_bytes(self.f, 1000)
|
||||
self.assertEqual(out, '1234567890')
|
||||
self.assertFalse(remaining > 0)
|
||||
|
||||
def test_seek_too_far_real_file(self):
|
||||
# StringIO doesn't raise IOError if you see past the start of the file.
|
||||
flo = tempfile.TemporaryFile()
|
||||
content = '1234567890'
|
||||
flo.write(content)
|
||||
self.assertEqual((content, 0), utils.last_bytes(flo, 1000))
|
||||
|
||||
|
||||
class IntLikeTestCase(test.NoDBTestCase):
|
||||
|
||||
def test_is_int_like(self):
|
||||
self.assertTrue(utils.is_int_like(1))
|
||||
self.assertTrue(utils.is_int_like("1"))
|
||||
self.assertTrue(utils.is_int_like("514"))
|
||||
self.assertTrue(utils.is_int_like("0"))
|
||||
|
||||
self.assertFalse(utils.is_int_like(1.1))
|
||||
self.assertFalse(utils.is_int_like("1.1"))
|
||||
self.assertFalse(utils.is_int_like("1.1.1"))
|
||||
self.assertFalse(utils.is_int_like(None))
|
||||
self.assertFalse(utils.is_int_like("0."))
|
||||
self.assertFalse(utils.is_int_like("aaaaaa"))
|
||||
self.assertFalse(utils.is_int_like("...."))
|
||||
self.assertFalse(utils.is_int_like("1g"))
|
||||
self.assertFalse(
|
||||
utils.is_int_like("0cc3346e-9fef-4445-abe6-5d2b2690ec64"))
|
||||
self.assertFalse(utils.is_int_like("a1"))
|
||||
|
||||
|
||||
class MetadataToDictTestCase(test.NoDBTestCase):
|
||||
def test_metadata_to_dict(self):
|
||||
self.assertEqual(utils.metadata_to_dict(
|
||||
[{'key': 'foo1', 'value': 'bar'},
|
||||
{'key': 'foo2', 'value': 'baz'}]),
|
||||
{'foo1': 'bar', 'foo2': 'baz'})
|
||||
|
||||
def test_metadata_to_dict_empty(self):
|
||||
self.assertEqual(utils.metadata_to_dict([]), {})
|
||||
|
||||
def test_dict_to_metadata(self):
|
||||
expected = [{'key': 'foo1', 'value': 'bar1'},
|
||||
{'key': 'foo2', 'value': 'bar2'}]
|
||||
self.assertEqual(utils.dict_to_metadata(dict(foo1='bar1',
|
||||
foo2='bar2')),
|
||||
expected)
|
||||
|
||||
def test_dict_to_metadata_empty(self):
|
||||
self.assertEqual(utils.dict_to_metadata({}), [])
|
||||
|
||||
|
||||
class WrappedCodeTestCase(test.NoDBTestCase):
|
||||
"""Test the get_wrapped_function utility method."""
|
||||
|
||||
def _wrapper(self, function):
|
||||
@functools.wraps(function)
|
||||
def decorated_function(self, *args, **kwargs):
|
||||
function(self, *args, **kwargs)
|
||||
return decorated_function
|
||||
|
||||
def test_single_wrapped(self):
|
||||
@self._wrapper
|
||||
def wrapped(self, instance, red=None, blue=None):
|
||||
pass
|
||||
|
||||
func = utils.get_wrapped_function(wrapped)
|
||||
func_code = func.func_code
|
||||
self.assertEqual(4, len(func_code.co_varnames))
|
||||
self.assertIn('self', func_code.co_varnames)
|
||||
self.assertIn('instance', func_code.co_varnames)
|
||||
self.assertIn('red', func_code.co_varnames)
|
||||
self.assertIn('blue', func_code.co_varnames)
|
||||
|
||||
def test_double_wrapped(self):
|
||||
@self._wrapper
|
||||
@self._wrapper
|
||||
def wrapped(self, instance, red=None, blue=None):
|
||||
pass
|
||||
|
||||
func = utils.get_wrapped_function(wrapped)
|
||||
func_code = func.func_code
|
||||
self.assertEqual(4, len(func_code.co_varnames))
|
||||
self.assertIn('self', func_code.co_varnames)
|
||||
self.assertIn('instance', func_code.co_varnames)
|
||||
self.assertIn('red', func_code.co_varnames)
|
||||
self.assertIn('blue', func_code.co_varnames)
|
||||
|
||||
def test_triple_wrapped(self):
|
||||
@self._wrapper
|
||||
@self._wrapper
|
||||
@self._wrapper
|
||||
def wrapped(self, instance, red=None, blue=None):
|
||||
pass
|
||||
|
||||
func = utils.get_wrapped_function(wrapped)
|
||||
func_code = func.func_code
|
||||
self.assertEqual(4, len(func_code.co_varnames))
|
||||
self.assertIn('self', func_code.co_varnames)
|
||||
self.assertIn('instance', func_code.co_varnames)
|
||||
self.assertIn('red', func_code.co_varnames)
|
||||
self.assertIn('blue', func_code.co_varnames)
|
||||
|
||||
|
||||
class ExpectedArgsTestCase(test.NoDBTestCase):
|
||||
def test_passes(self):
|
||||
@utils.expects_func_args('foo', 'baz')
|
||||
def dec(f):
|
||||
return f
|
||||
|
||||
@dec
|
||||
def func(foo, bar, baz="lol"):
|
||||
pass
|
||||
|
||||
def test_raises(self):
|
||||
@utils.expects_func_args('foo', 'baz')
|
||||
def dec(f):
|
||||
return f
|
||||
|
||||
def func(bar, baz):
|
||||
pass
|
||||
|
||||
self.assertRaises(TypeError, dec, func)
|
||||
|
||||
def test_var_no_of_args(self):
|
||||
@utils.expects_func_args('foo')
|
||||
def dec(f):
|
||||
return f
|
||||
|
||||
@dec
|
||||
def func(bar, *args, **kwargs):
|
||||
pass
|
||||
|
||||
def test_more_layers(self):
|
||||
@utils.expects_func_args('foo', 'baz')
|
||||
def dec(f):
|
||||
return f
|
||||
|
||||
def dec_2(f):
|
||||
def inner_f(*a, **k):
|
||||
return f()
|
||||
return inner_f
|
||||
|
||||
@dec_2
|
||||
def func(bar, baz):
|
||||
pass
|
||||
|
||||
self.assertRaises(TypeError, dec, func)
|
||||
|
||||
|
||||
class StringLengthTestCase(test.NoDBTestCase):
|
||||
def test_check_string_length(self):
|
||||
self.assertIsNone(utils.check_string_length(
|
||||
'test', 'name', max_length=255))
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.check_string_length,
|
||||
11, 'name', max_length=255)
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.check_string_length,
|
||||
'', 'name', min_length=1)
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.check_string_length,
|
||||
'a' * 256, 'name', max_length=255)
|
||||
|
||||
def test_check_string_length_noname(self):
|
||||
self.assertIsNone(utils.check_string_length(
|
||||
'test', max_length=255))
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.check_string_length,
|
||||
11, max_length=255)
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.check_string_length,
|
||||
'', min_length=1)
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.check_string_length,
|
||||
'a' * 256, max_length=255)
|
||||
|
||||
|
||||
class ValidateIntegerTestCase(test.NoDBTestCase):
|
||||
def test_valid_inputs(self):
|
||||
self.assertEqual(
|
||||
utils.validate_integer(42, "answer"), 42)
|
||||
self.assertEqual(
|
||||
utils.validate_integer("42", "answer"), 42)
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
"7", "lucky", min_value=7, max_value=8), 7)
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
7, "lucky", min_value=6, max_value=7), 7)
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
300, "Spartaaa!!!", min_value=300), 300)
|
||||
self.assertEqual(
|
||||
utils.validate_integer(
|
||||
"300", "Spartaaa!!!", max_value=300), 300)
|
||||
|
||||
def test_invalid_inputs(self):
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.validate_integer,
|
||||
"im-not-an-int", "not-an-int")
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.validate_integer,
|
||||
3.14, "Pie")
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.validate_integer,
|
||||
"299", "Sparta no-show",
|
||||
min_value=300, max_value=300)
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.validate_integer,
|
||||
55, "doing 55 in a 54",
|
||||
max_value=54)
|
||||
self.assertRaises(exception.InvalidInput,
|
||||
utils.validate_integer,
|
||||
unichr(129), "UnicodeError",
|
||||
max_value=1000)
|
||||
|
||||
|
||||
class ValidateNeutronConfiguration(test.NoDBTestCase):
|
||||
def test_nova_network(self):
|
||||
self.assertFalse(utils.is_neutron())
|
||||
|
||||
def test_neutron(self):
|
||||
self.flags(network_api_class='nova.network.neutronv2.api.API')
|
||||
self.assertTrue(utils.is_neutron())
|
||||
|
||||
def test_quantum(self):
|
||||
self.flags(network_api_class='nova.network.quantumv2.api.API')
|
||||
self.assertTrue(utils.is_neutron())
|
||||
|
||||
|
||||
class AutoDiskConfigUtilTestCase(test.NoDBTestCase):
|
||||
def test_is_auto_disk_config_disabled(self):
|
||||
self.assertTrue(utils.is_auto_disk_config_disabled("Disabled "))
|
||||
|
||||
def test_is_auto_disk_config_disabled_none(self):
|
||||
self.assertFalse(utils.is_auto_disk_config_disabled(None))
|
||||
|
||||
def test_is_auto_disk_config_disabled_false(self):
|
||||
self.assertFalse(utils.is_auto_disk_config_disabled("false"))
|
||||
|
||||
|
||||
class GetSystemMetadataFromImageTestCase(test.NoDBTestCase):
|
||||
def get_image(self):
|
||||
image_meta = {
|
||||
"id": "fake-image",
|
||||
"name": "fake-name",
|
||||
"min_ram": 1,
|
||||
"min_disk": 1,
|
||||
"disk_format": "raw",
|
||||
"container_format": "bare",
|
||||
}
|
||||
|
||||
return image_meta
|
||||
|
||||
def get_flavor(self):
|
||||
flavor = {
|
||||
"id": "fake.flavor",
|
||||
"root_gb": 10,
|
||||
}
|
||||
|
||||
return flavor
|
||||
|
||||
def test_base_image_properties(self):
|
||||
image = self.get_image()
|
||||
|
||||
# Verify that we inherit all the needed keys
|
||||
sys_meta = utils.get_system_metadata_from_image(image)
|
||||
for key in utils.SM_INHERITABLE_KEYS:
|
||||
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, key)
|
||||
self.assertEqual(image[key], sys_meta.get(sys_key))
|
||||
|
||||
# Verify that everything else is ignored
|
||||
self.assertEqual(len(sys_meta), len(utils.SM_INHERITABLE_KEYS))
|
||||
|
||||
def test_inherit_image_properties(self):
|
||||
image = self.get_image()
|
||||
image["properties"] = {"foo1": "bar", "foo2": "baz"}
|
||||
|
||||
sys_meta = utils.get_system_metadata_from_image(image)
|
||||
|
||||
# Verify that we inherit all the image properties
|
||||
for key, expected in image["properties"].iteritems():
|
||||
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, key)
|
||||
self.assertEqual(sys_meta[sys_key], expected)
|
||||
|
||||
def test_vhd_min_disk_image(self):
|
||||
image = self.get_image()
|
||||
flavor = self.get_flavor()
|
||||
|
||||
image["disk_format"] = "vhd"
|
||||
|
||||
sys_meta = utils.get_system_metadata_from_image(image, flavor)
|
||||
|
||||
# Verify that the min_disk property is taken from
|
||||
# flavor's root_gb when using vhd disk format
|
||||
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, "min_disk")
|
||||
self.assertEqual(sys_meta[sys_key], flavor["root_gb"])
|
||||
|
||||
def test_dont_inherit_empty_values(self):
|
||||
image = self.get_image()
|
||||
|
||||
for key in utils.SM_INHERITABLE_KEYS:
|
||||
image[key] = None
|
||||
|
||||
sys_meta = utils.get_system_metadata_from_image(image)
|
||||
|
||||
# Verify that the empty properties have not been inherited
|
||||
for key in utils.SM_INHERITABLE_KEYS:
|
||||
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, key)
|
||||
self.assertNotIn(sys_key, sys_meta)
|
||||
|
||||
|
||||
class GetImageFromSystemMetadataTestCase(test.NoDBTestCase):
|
||||
def get_system_metadata(self):
|
||||
sys_meta = {
|
||||
"image_min_ram": 1,
|
||||
"image_min_disk": 1,
|
||||
"image_disk_format": "raw",
|
||||
"image_container_format": "bare",
|
||||
}
|
||||
|
||||
return sys_meta
|
||||
|
||||
def test_image_from_system_metadata(self):
|
||||
sys_meta = self.get_system_metadata()
|
||||
sys_meta["%soo1" % utils.SM_IMAGE_PROP_PREFIX] = "bar"
|
||||
sys_meta["%soo2" % utils.SM_IMAGE_PROP_PREFIX] = "baz"
|
||||
|
||||
image = utils.get_image_from_system_metadata(sys_meta)
|
||||
|
||||
# Verify that we inherit all the needed keys
|
||||
for key in utils.SM_INHERITABLE_KEYS:
|
||||
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, key)
|
||||
self.assertEqual(image[key], sys_meta.get(sys_key))
|
||||
|
||||
# Verify that we inherit the rest of metadata as properties
|
||||
self.assertIn("properties", image)
|
||||
|
||||
for key, value in image["properties"].iteritems():
|
||||
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, key)
|
||||
self.assertEqual(image["properties"][key], sys_meta[sys_key])
|
||||
|
||||
def test_dont_inherit_empty_values(self):
|
||||
sys_meta = self.get_system_metadata()
|
||||
|
||||
for key in utils.SM_INHERITABLE_KEYS:
|
||||
sys_key = "%s%s" % (utils.SM_IMAGE_PROP_PREFIX, key)
|
||||
sys_meta[sys_key] = None
|
||||
|
||||
image = utils.get_image_from_system_metadata(sys_meta)
|
||||
|
||||
# Verify that the empty properties have not been inherited
|
||||
for key in utils.SM_INHERITABLE_KEYS:
|
||||
self.assertNotIn(key, image)
|
||||
|
||||
def test_non_inheritable_image_properties(self):
|
||||
sys_meta = self.get_system_metadata()
|
||||
sys_meta["%soo1" % utils.SM_IMAGE_PROP_PREFIX] = "bar"
|
||||
|
||||
self.flags(non_inheritable_image_properties=["foo1"])
|
||||
|
||||
image = utils.get_image_from_system_metadata(sys_meta)
|
||||
|
||||
# Verify that the foo1 key has not been inherited
|
||||
self.assertNotIn("foo1", image)
|
||||
|
||||
|
||||
class VersionTestCase(test.NoDBTestCase):
|
||||
def test_convert_version_to_int(self):
|
||||
self.assertEqual(utils.convert_version_to_int('6.2.0'), 6002000)
|
||||
|
|
@ -872,83 +35,3 @@ class VersionTestCase(test.NoDBTestCase):
|
|||
|
||||
def test_convert_version_to_tuple(self):
|
||||
self.assertEqual(utils.convert_version_to_tuple('6.7.0'), (6, 7, 0))
|
||||
|
||||
|
||||
class ConstantTimeCompareTestCase(test.NoDBTestCase):
|
||||
def test_constant_time_compare(self):
|
||||
self.assertTrue(utils.constant_time_compare("abcd1234", "abcd1234"))
|
||||
self.assertFalse(utils.constant_time_compare("abcd1234", "a"))
|
||||
self.assertFalse(utils.constant_time_compare("abcd1234", "ABCD234"))
|
||||
|
||||
|
||||
class ResourceFilterTestCase(test.NoDBTestCase):
|
||||
def _assert_filtering(self, res_list, filts, expected_tags):
|
||||
actual_tags = utils.filter_and_format_resource_metadata('instance',
|
||||
res_list, filts, 'metadata')
|
||||
self.assertEqual(expected_tags, actual_tags)
|
||||
|
||||
def test_filter_and_format_resource_metadata(self):
|
||||
# Create some tags
|
||||
# One overlapping pair, and one different key value pair
|
||||
# i1 : foo=bar, bax=wibble
|
||||
# i2 : foo=bar, baz=quux
|
||||
|
||||
# resources
|
||||
i1 = {
|
||||
'uuid': '1',
|
||||
'metadata': {'foo': 'bar', 'bax': 'wibble'},
|
||||
}
|
||||
i2 = {
|
||||
'uuid': '2',
|
||||
'metadata': {'foo': 'bar', 'baz': 'quux'},
|
||||
}
|
||||
|
||||
# Resources list
|
||||
rl = [i1, i2]
|
||||
|
||||
# tags
|
||||
i11 = {'instance_id': '1', 'key': 'foo', 'value': 'bar'}
|
||||
i12 = {'instance_id': '1', 'key': 'bax', 'value': 'wibble'}
|
||||
i21 = {'instance_id': '2', 'key': 'foo', 'value': 'bar'}
|
||||
i22 = {'instance_id': '2', 'key': 'baz', 'value': 'quux'}
|
||||
|
||||
# No filter
|
||||
self._assert_filtering(rl, [], [i11, i12, i21, i22])
|
||||
self._assert_filtering(rl, {}, [i11, i12, i21, i22])
|
||||
|
||||
# Key search
|
||||
|
||||
# Both should have tags with key 'foo' and value 'bar'
|
||||
self._assert_filtering(rl, {'key': 'foo', 'value': 'bar'}, [i11, i21])
|
||||
|
||||
# Both should have tags with key 'foo'
|
||||
self._assert_filtering(rl, {'key': 'foo'}, [i11, i21])
|
||||
|
||||
# Only i2 should have tags with key 'baz' and value 'quux'
|
||||
self._assert_filtering(rl, {'key': 'baz', 'value': 'quux'}, [i22])
|
||||
|
||||
# Only i2 should have tags with value 'quux'
|
||||
self._assert_filtering(rl, {'value': 'quux'}, [i22])
|
||||
|
||||
# Empty list should be returned when no tags match
|
||||
self._assert_filtering(rl, {'key': 'split', 'value': 'banana'}, [])
|
||||
|
||||
# Multiple values
|
||||
|
||||
# Only i2 should have tags with key 'baz' and values in the set
|
||||
# ['quux', 'wibble']
|
||||
self._assert_filtering(rl, {'key': 'baz', 'value': ['quux', 'wibble']},
|
||||
[i22])
|
||||
|
||||
# But when specified as two different filters, no tags should be
|
||||
# returned. This is because, the filter will mean "return tags which
|
||||
# have (key=baz AND value=quux) AND (key=baz AND value=wibble)
|
||||
self._assert_filtering(rl, [{'key': 'baz', 'value': 'quux'},
|
||||
{'key': 'baz', 'value': 'wibble'}], [])
|
||||
|
||||
# Test for regex
|
||||
self._assert_filtering(rl, {'value': '\\Aqu..*\\Z(?s)'}, [i22])
|
||||
|
||||
# Make sure bug #1365887 is fixed
|
||||
i1['metadata']['key3'] = 'a'
|
||||
self._assert_filtering(rl, {'value': 'banana'}, [])
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -7,3 +7,5 @@ oslo.messaging>=1.4.0,!=1.5.0
|
|||
oslo.serialization>=1.2.0 # Apache-2.0
|
||||
oslo.utils>=1.2.0 # Apache-2.0
|
||||
iso8601>=0.1.9
|
||||
oslo.log>=0.1.0
|
||||
oslo.i18n>=1.3.0 # Apache-2.0
|
||||
|
|
|
|||
3
tox.ini
3
tox.ini
|
|
@ -10,8 +10,11 @@ envlist = py33,py34,py26,py27,pypy,pep8
|
|||
# for oslo libraries because of the namespace package.
|
||||
#usedevelop = True
|
||||
install_command = pip install -U {opts} {packages}
|
||||
# FIXME(dhellmann): test_objects._TestObject.test_base_attributes
|
||||
# fails with a random hash seed, so set PYTHONHASHSEED.
|
||||
setenv =
|
||||
VIRTUAL_ENV={envdir}
|
||||
PYTHONHASHSEED=0
|
||||
deps = -r{toxinidir}/requirements.txt
|
||||
-r{toxinidir}/test-requirements.txt
|
||||
commands = python setup.py testr --slowest --testr-args='{posargs}'
|
||||
|
|
|
|||
Loading…
Reference in New Issue