openstack
/
ironic
Code Issues Proposed changes

Use functions from oslo.utils 

Functions is_int_like(), generate_uuid() is_uuid_like() available in
oslo.utils, so we can use them from there and remove duplicates from
Ironic code

Change-Id: I2a319e633a835dbca6831148acaf425e4ff6a725
This commit is contained in:
Victor Sergeyev 2015-02-23 12:46:30 +02:00
parent b1f932a5c1
commit fe6be4d49f
33 changed files with 186 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
ironic/api/controllers/v1/node.py
View File

@ -17,6 +17,7 @@ import ast
import datetime
from oslo_config import cfg
from oslo_utils import uuidutils
import pecan
from pecan import rest
import wsme
@ -88,7 +89,7 @@ def allow_logical_names():
def is_valid_name(name):
return utils.is_hostname_safe(name) and (not utils.is_uuid_like(name))
return utils.is_hostname_safe(name) and (not uuidutils.is_uuid_like(name))
def _get_rpc_node(node_ident):
@ -103,7 +104,7 @@ def _get_rpc_node(node_ident):
"""
# Check to see if the node_ident is a valid UUID. If it is, treat it
# as a UUID.
if utils.is_uuid_like(node_ident):
if uuidutils.is_uuid_like(node_ident):
return objects.Node.get_by_uuid(pecan.request.context, node_ident)
# If it was not UUID-like, but it is name-like, and we allow names,
@ -920,7 +921,7 @@ class NodesController(rest.RestController):
if node:
# We're invoking this interface using positional notation, or
# explicitly using 'node'. Try and determine which one.
if not allow_logical_names() and not utils.is_uuid_like(node):
if not allow_logical_names() and not uuidutils.is_uuid_like(node):
raise exception.NotAcceptable()
rpc_node = _get_rpc_node(node_uuid or node)
@ -955,7 +956,7 @@ class NodesController(rest.RestController):
# We need to ensure that node has a UUID before it can
# be mapped onto the hash ring.
if not node.uuid:
node.uuid = utils.generate_uuid()
node.uuid = uuidutils.generate_uuid()
try:
pecan.request.rpcapi.get_topic_for(node)

6
ironic/api/controllers/v1/types.py
View File

@ -18,6 +18,7 @@
import json
from oslo_utils import strutils
from oslo_utils import uuidutils
import six
import wsme
from wsme import types as wtypes
@ -62,7 +63,8 @@ class UuidOrNameType(wtypes.UserType):
@staticmethod
def validate(value):
if not (utils.is_uuid_like(value) or utils.is_hostname_safe(value)):
if not (uuidutils.is_uuid_like(value)
or utils.is_hostname_safe(value)):
raise exception.InvalidUuidOrName(name=value)
return value
@ -110,7 +112,7 @@ class UuidType(wtypes.UserType):
@staticmethod
def validate(value):
if not utils.is_uuid_like(value):
if not uuidutils.is_uuid_like(value):
raise exception.InvalidUUID(uuid=value)
return value

4
ironic/common/glance_service/v2/image_service.py
View File

@ -14,6 +14,7 @@
# under the License.
from oslo_config import cfg
from oslo_utils import uuidutils
from swiftclient import utils as swift_utils
from ironic.common import exception as exc
@ -21,7 +22,6 @@ from ironic.common.glance_service import base_image_service
from ironic.common.glance_service import service
from ironic.common.glance_service import service_utils
from ironic.common.i18n import _
from ironic.common import utils
glance_opts = [
@ -135,7 +135,7 @@ class GlanceImageService(base_image_service.BaseImageService,
self._validate_temp_url_config()
if ('id' not in image_info or not
utils.is_uuid_like(image_info['id'])):
uuidutils.is_uuid_like(image_info['id'])):
raise exc.ImageUnacceptable(_(
'The given image info does not have a valid image id: %s')
% image_info)

26
ironic/common/utils.py
View File

@ -26,7 +26,6 @@ import random
import re
import shutil
import tempfile
import uuid
import netaddr
from oslo_concurrency import processutils
@ -157,14 +156,6 @@ def delete_if_exists(pathname):
raise
def is_int_like(val):
"""Check if a value looks like an int."""
try:
return str(int(val)) == str(val)
except Exception:
return False
def is_valid_boolstr(val):
"""Check if the provided string is a valid bool string or not."""
boolstrs = ('true', 'false', 'yes', 'no', 'y', 'n', '1', '0')
@ -488,23 +479,6 @@ def safe_rstrip(value, chars=None):
return value.rstrip(chars) or value
def generate_uuid():
return str(uuid.uuid4())
def is_uuid_like(val):
"""Returns validation of a value as a UUID.
For our purposes, a UUID is a canonical form string:
aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa
"""
try:
return str(uuid.UUID(val)) == val
except (TypeError, ValueError, AttributeError):
return False
def mount(src, dest, *args):
"""Mounts a device/image file on specified location.

4
ironic/conductor/manager.py
View File

@ -54,6 +54,7 @@ from oslo_concurrency import lockutils
from oslo_config import cfg
from oslo_db import exception as db_exception
from oslo_utils import excutils
from oslo_utils import uuidutils
from ironic.common import dhcp_factory
from ironic.common import driver_factory
@ -68,7 +69,6 @@ from ironic.common import keystone
from ironic.common import rpc
from ironic.common import states
from ironic.common import swift
from ironic.common import utils as ironic_utils
from ironic.conductor import task_manager
from ironic.conductor import utils
from ironic.db import api as dbapi
@ -1210,7 +1210,7 @@ class ConductorManager(periodic_task.PeriodicTasks):
continue
# populate the message which will be sent to ceilometer
message = {'message_id': ironic_utils.generate_uuid(),
message = {'message_id': uuidutils.generate_uuid(),
'instance_uuid': instance_uuid,
'node_uuid': node_uuid,
'timestamp': datetime.datetime.utcnow(),

2
ironic/db/api.py
View File

@ -133,7 +133,7 @@ class Connection(object):
::
{
'uuid': utils.generate_uuid(),
'uuid': uuidutils.generate_uuid(),
'instance_uuid': None,
'power_state': states.POWER_OFF,
'provision_state': states.AVAILABLE,

20
ironic/db/sqlalchemy/api.py
View File

@ -23,7 +23,9 @@ from oslo_config import cfg
from oslo_db import exception as db_exc
from oslo_db.sqlalchemy import session as db_session
from oslo_db.sqlalchemy import utils as db_utils
from oslo_utils import strutils
from oslo_utils import timeutils
from oslo_utils import uuidutils
from sqlalchemy.orm.exc import NoResultFound
from ironic.common import exception
@ -89,9 +91,9 @@ def add_identity_filter(query, value):
:param value: Value for filtering results by.
:return: Modified query.
"""
if utils.is_int_like(value):
if strutils.is_int_like(value):
return query.filter_by(id=value)
elif utils.is_uuid_like(value):
elif uuidutils.is_uuid_like(value):
return query.filter_by(uuid=value)
else:
raise exception.InvalidIdentity(identity=value)
@ -114,7 +116,7 @@ def add_port_filter(query, value):
def add_port_filter_by_node(query, value):
if utils.is_int_like(value):
if strutils.is_int_like(value):
return query.filter_by(node_id=value)
else:
query = query.join(models.Node,
@ -123,7 +125,7 @@ def add_port_filter_by_node(query, value):
def add_node_filter_by_chassis(query, value):
if utils.is_int_like(value):
if strutils.is_int_like(value):
return query.filter_by(chassis_id=value)
else:
query = query.join(models.Chassis,
@ -254,7 +256,7 @@ class Connection(api.Connection):
def create_node(self, values):
# ensure defaults are present for new nodes
if 'uuid' not in values:
values['uuid'] = utils.generate_uuid()
values['uuid'] = uuidutils.generate_uuid()
if 'power_state' not in values:
values['power_state'] = states.NOSTATE
if 'provision_state' not in values:
@ -297,7 +299,7 @@ class Connection(api.Connection):
raise exception.NodeNotFound(node=node_name)
def get_node_by_instance(self, instance):
if not utils.is_uuid_like(instance):
if not uuidutils.is_uuid_like(instance):
raise exception.InvalidUUID(uuid=instance)
query = (model_query(models.Node)
@ -323,7 +325,7 @@ class Connection(api.Connection):
# Get node ID, if an UUID was supplied. The ID is
# required for deleting all ports, attached to the node.
if utils.is_uuid_like(node_id):
if uuidutils.is_uuid_like(node_id):
node_id = node_ref['id']
port_query = model_query(models.Port, session=session)
@ -408,7 +410,7 @@ class Connection(api.Connection):
def create_port(self, values):
if not values.get('uuid'):
values['uuid'] = utils.generate_uuid()
values['uuid'] = uuidutils.generate_uuid()
port = models.Port()
port.update(values)
try:
@ -473,7 +475,7 @@ class Connection(api.Connection):
def create_chassis(self, values):
if not values.get('uuid'):
values['uuid'] = utils.generate_uuid()
values['uuid'] = uuidutils.generate_uuid()
chassis = models.Chassis()
chassis.update(values)
try:

4
ironic/migrate_nova/migrate_db.py
View File

@ -15,11 +15,11 @@ import ConfigParser
import os
import sys
from oslo_utils import uuidutils
import sqlalchemy as sa
from sqlalchemy.orm import sessionmaker
from ironic.common import states as ironic_states
from ironic.common import utils
from ironic.db.sqlalchemy import models as ironic_models
from ironic.migrate_nova import nova_baremetal_states as nova_states
from ironic.migrate_nova import nova_models
@ -186,7 +186,7 @@ def convert_nova_ports(ports):
i_port = ironic_models.Port()
i_port.id = n_port.id
i_port.uuid = utils.generate_uuid()
i_port.uuid = uuidutils.generate_uuid()
i_port.address = n_port.address
i_port.node_id = n_port.bm_node_id

8
ironic/objects/chassis.py
View File

@ -13,8 +13,10 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_utils import strutils
from oslo_utils import uuidutils
from ironic.common import exception
from ironic.common import utils
from ironic.db import api as dbapi
from ironic.objects import base
from ironic.objects import utils as obj_utils
@ -58,9 +60,9 @@ class Chassis(base.IronicObject):
:param chassis_id: the id *or* uuid of a chassis.
:returns: a :class:`Chassis` object.
"""
if utils.is_int_like(chassis_id):
if strutils.is_int_like(chassis_id):
return cls.get_by_id(context, chassis_id)
elif utils.is_uuid_like(chassis_id):
elif uuidutils.is_uuid_like(chassis_id):
return cls.get_by_uuid(context, chassis_id)
else:
raise exception.InvalidIdentity(identity=chassis_id)

8
ironic/objects/node.py
View File

@ -13,8 +13,10 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_utils import strutils
from oslo_utils import uuidutils
from ironic.common import exception
from ironic.common import utils
from ironic.db import api as db_api
from ironic.objects import base
from ironic.objects import utils as obj_utils
@ -95,9 +97,9 @@ class Node(base.IronicObject):
:param node_id: the id *or* uuid of a node.
:returns: a :class:`Node` object.
"""
if utils.is_int_like(node_id):
if strutils.is_int_like(node_id):
return cls.get_by_id(context, node_id)
elif utils.is_uuid_like(node_id):
elif uuidutils.is_uuid_like(node_id):
return cls.get_by_uuid(context, node_id)
else:
raise exception.InvalidIdentity(identity=node_id)

7
ironic/objects/port.py
View File

@ -13,6 +13,9 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_utils import strutils
from oslo_utils import uuidutils
from ironic.common import exception
from ironic.common import utils
from ironic.db import api as dbapi
@ -60,9 +63,9 @@ class Port(base.IronicObject):
:param port_id: the id *or* uuid of a port.
:returns: a :class:`Port` object.
"""
if utils.is_int_like(port_id):
if strutils.is_int_like(port_id):
return cls.get_by_id(context, port_id)
elif utils.is_uuid_like(port_id):
elif uuidutils.is_uuid_like(port_id):
return cls.get_by_uuid(context, port_id)
elif utils.is_valid_mac(port_id):
return cls.get_by_address(context, port_id)

26
ironic/tests/api/v1/test_chassis.py
View File

@ -20,11 +20,11 @@ import datetime
import mock
from oslo_config import cfg
from oslo_utils import timeutils
from oslo_utils import uuidutils
from six.moves.urllib import parse as urlparse
from wsme import types as wtypes
from ironic.api.controllers.v1 import chassis as api_chassis
from ironic.common import utils
from ironic.tests.api import base as api_base
from ironic.tests.api import utils as apiutils
from ironic.tests import base
@ -76,8 +76,8 @@ class TestListChassis(api_base.FunctionalTest):
def test_many(self):
ch_list = []
for id_ in range(5):
chassis = obj_utils.create_test_chassis(self.context, id=id_,
uuid=utils.generate_uuid())
chassis = obj_utils.create_test_chassis(
self.context, id=id_, uuid=uuidutils.generate_uuid())
ch_list.append(chassis.uuid)
data = self.get_json('/chassis')
self.assertEqual(len(ch_list), len(data['chassis']))
@ -85,7 +85,7 @@ class TestListChassis(api_base.FunctionalTest):
self.assertEqual(ch_list.sort(), uuids.sort())
def test_links(self):
uuid = utils.generate_uuid()
uuid = uuidutils.generate_uuid()
obj_utils.create_test_chassis(self.context, id=1, uuid=uuid)
data = self.get_json('/chassis/%s' % uuid)
self.assertIn('links', data.keys())
@ -98,7 +98,7 @@ class TestListChassis(api_base.FunctionalTest):
def test_collection_links(self):
for id in range(5):
obj_utils.create_test_chassis(self.context, id=id,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
data = self.get_json('/chassis/?limit=3')
self.assertEqual(3, len(data['chassis']))
@ -109,7 +109,7 @@ class TestListChassis(api_base.FunctionalTest):
cfg.CONF.set_override('max_limit', 3, 'api')
for id_ in range(5):
obj_utils.create_test_chassis(self.context, id=id_,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
data = self.get_json('/chassis')
self.assertEqual(3, len(data['chassis']))
@ -127,7 +127,7 @@ class TestListChassis(api_base.FunctionalTest):
for id_ in range(2):
obj_utils.create_test_node(self.context,
chassis_id=chassis.id,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
data = self.get_json('/chassis/%s/nodes' % chassis.uuid)
self.assertEqual(2, len(data['nodes']))
@ -156,7 +156,7 @@ class TestPatch(api_base.FunctionalTest):
obj_utils.create_test_chassis(self.context)
def test_update_not_found(self):
uuid = utils.generate_uuid()
uuid = uuidutils.generate_uuid()
response = self.patch_json('/chassis/%s' % uuid,
[{'path': '/extra/a', 'value': 'b',
'op': 'add'}],
@ -186,7 +186,7 @@ class TestPatch(api_base.FunctionalTest):
def test_replace_multi(self):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
chassis = obj_utils.create_test_chassis(self.context, extra=extra,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
id=1)
new_value = 'new value'
response = self.patch_json('/chassis/%s' % chassis.uuid,
@ -201,7 +201,7 @@ class TestPatch(api_base.FunctionalTest):
def test_remove_singular(self):
chassis = obj_utils.create_test_chassis(self.context, extra={'a': 'b'},
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
id=1)
response = self.patch_json('/chassis/%s' % chassis.uuid,
[{'path': '/description', 'op': 'remove'}])
@ -218,7 +218,7 @@ class TestPatch(api_base.FunctionalTest):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
chassis = obj_utils.create_test_chassis(self.context, extra=extra,
description="foobar",
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
id=1)
# Removing one item from the collection
@ -339,7 +339,7 @@ class TestPost(api_base.FunctionalTest):
result = self.get_json('/chassis')
self.assertEqual(cdict['description'],
result['chassis'][0]['description'])
self.assertTrue(utils.is_uuid_like(result['chassis'][0]['uuid']))
self.assertTrue(uuidutils.is_uuid_like(result['chassis'][0]['uuid']))
def test_post_nodes_subresource(self):
chassis = obj_utils.create_test_chassis(self.context)
@ -388,7 +388,7 @@ class TestDelete(api_base.FunctionalTest):
self.assertIn(chassis.uuid, response.json['error_message'])
def test_delete_chassis_not_found(self):
uuid = utils.generate_uuid()
uuid = uuidutils.generate_uuid()
response = self.delete('/chassis/%s' % uuid, expect_errors=True)
self.assertEqual(404, response.status_int)
self.assertEqual('application/json', response.content_type)

58
ironic/tests/api/v1/test_nodes.py
View File

@ -21,6 +21,7 @@ import json
import mock
from oslo_config import cfg
from oslo_utils import timeutils
from oslo_utils import uuidutils
import pecan
from six.moves.urllib import parse as urlparse
from testtools.matchers import HasLength
@ -32,7 +33,6 @@ from ironic.api.controllers.v1 import node as api_node
from ironic.common import boot_devices
from ironic.common import exception
from ironic.common import states
from ironic.common import utils
from ironic.conductor import rpcapi
from ironic import objects
from ironic.tests.api import base as test_api_base
@ -57,7 +57,7 @@ class TestTopLevelFunctions(base.TestCase):
def setUp(self):
super(TestTopLevelFunctions, self).setUp()
self.valid_name = 'my-host'
self.valid_uuid = utils.generate_uuid()
self.valid_uuid = uuidutils.generate_uuid()
self.invalid_name = 'Mr Plow'
self.invalid_uuid = '636-555-3226-'
self.node = post_get_test_node()
@ -141,15 +141,15 @@ class TestListNodes(test_api_base.FunctionalTest):
unassociated_nodes = []
for id in range(3):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
unassociated_nodes.append(node.uuid)
# created some associated nodes
associated_nodes = []
for id in range(4):
node = obj_utils.create_test_node(
self.context, uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
self.context, uuid=uuidutils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid())
associated_nodes.append(node.uuid)
return {'associated': associated_nodes,
'unassociated': unassociated_nodes}
@ -266,7 +266,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = []
for id in range(5):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
nodes.append(node.uuid)
data = self.get_json('/nodes')
self.assertEqual(len(nodes), len(data['nodes']))
@ -280,7 +280,7 @@ class TestListNodes(test_api_base.FunctionalTest):
for id in range(5):
name = 'node-%s' % id
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
name=name)
nodes.append(node.uuid)
node_names.append(name)
@ -291,7 +291,7 @@ class TestListNodes(test_api_base.FunctionalTest):
self.assertEqual(sorted(node_names), sorted(names))
def test_links(self):
uuid = utils.generate_uuid()
uuid = uuidutils.generate_uuid()
obj_utils.create_test_node(self.context, uuid=uuid)
data = self.get_json('/nodes/%s' % uuid)
self.assertIn('links', data.keys())
@ -305,7 +305,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = []
for id in range(5):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
nodes.append(node.uuid)
data = self.get_json('/nodes/?limit=3')
self.assertEqual(3, len(data['nodes']))
@ -318,7 +318,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = []
for id in range(5):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
nodes.append(node.uuid)
data = self.get_json('/nodes')
self.assertEqual(3, len(data['nodes']))
@ -336,7 +336,7 @@ class TestListNodes(test_api_base.FunctionalTest):
for id_ in range(2):
obj_utils.create_test_port(self.context, node_id=node.id,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_)
data = self.get_json('/nodes/%s/ports' % node.uuid)
@ -412,9 +412,10 @@ class TestListNodes(test_api_base.FunctionalTest):
self.assertFalse(data['console_enabled'])
def test_node_by_instance_uuid(self):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
node = obj_utils.create_test_node(
self.context,
uuid=uuidutils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid())
instance_uuid = node.instance_uuid
data = self.get_json('/nodes?instance_uuid=%s' % instance_uuid,
@ -425,9 +426,10 @@ class TestListNodes(test_api_base.FunctionalTest):
data['nodes'][0]["instance_uuid"])
def test_node_by_instance_uuid_wrong_uuid(self):
obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
wrong_uuid = utils.generate_uuid()
obj_utils.create_test_node(
self.context, uuid=uuidutils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid())
wrong_uuid = uuidutils.generate_uuid()
data = self.get_json('/nodes?instance_uuid=%s' % wrong_uuid)
@ -505,9 +507,10 @@ class TestListNodes(test_api_base.FunctionalTest):
self.assertIn('associated=True', data['next'])
def test_detail_with_instance_uuid(self):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
node = obj_utils.create_test_node(
self.context,
uuid=uuidutils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid())
instance_uuid = node.instance_uuid
data = self.get_json('/nodes/detail?instance_uuid=%s' % instance_uuid)
@ -526,7 +529,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = []
for id in range(5):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
maintenance=id % 2)
nodes.append(node)
@ -549,9 +552,10 @@ class TestListNodes(test_api_base.FunctionalTest):
def test_maintenance_nodes_associated(self):
self._create_association_test_nodes()
node = obj_utils.create_test_node(self.context,
instance_uuid=utils.generate_uuid(),
maintenance=True)
node = obj_utils.create_test_node(
self.context,
instance_uuid=uuidutils.generate_uuid(),
maintenance=True)
data = self.get_json('/nodes?associated=true&maintenance=false')
uuids = [n['uuid'] for n in data['nodes']]
@ -884,7 +888,7 @@ class TestPatch(test_api_base.FunctionalTest):
def test_update_state_in_progress(self):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
target_power_state=states.POWER_OFF)
response = self.patch_json('/nodes/%s' % node.uuid,
[{'path': '/extra/foo', 'value': 'bar',
@ -895,7 +899,7 @@ class TestPatch(test_api_base.FunctionalTest):
def test_add_state_in_deployfail(self):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
provision_state=states.DEPLOYFAIL,
target_provision_state=states.ACTIVE)
self.mock_update_node.return_value = node
@ -1097,7 +1101,7 @@ class TestPatch(test_api_base.FunctionalTest):
def test_patch_duplicate_name(self):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid())
uuid=uuidutils.generate_uuid())
test_name = "this-is-my-node"
self.mock_update_node.side_effect = exception.DuplicateName(test_name)
response = self.patch_json('/nodes/%s' % node.uuid,

18
ironic/tests/api/v1/test_ports.py
View File

@ -20,13 +20,13 @@ import datetime
import mock
from oslo_config import cfg
from oslo_utils import timeutils
from oslo_utils import uuidutils
from six.moves.urllib import parse as urlparse
from testtools.matchers import HasLength
from wsme import types as wtypes
from ironic.api.controllers.v1 import port as api_port
from ironic.common import exception
from ironic.common import utils
from ironic.conductor import rpcapi
from ironic.tests.api import base as api_base
from ironic.tests.api import utils as apiutils
@ -102,7 +102,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(5):
port = obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid)
data = self.get_json('/ports')
@ -112,7 +112,7 @@ class TestListPorts(api_base.FunctionalTest):
self.assertEqual(ports.sort(), uuids.sort())
def test_links(self):
uuid = utils.generate_uuid()
uuid = uuidutils.generate_uuid()
obj_utils.create_test_port(self.context,
uuid=uuid,
node_id=self.node.id)
@ -129,7 +129,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(5):
port = obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid)
data = self.get_json('/ports/?limit=3')
@ -144,7 +144,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(5):
port = obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid)
data = self.get_json('/ports')
@ -158,7 +158,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(3):
obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
address=address_template % id_)
target_address = address_template % 1
@ -225,7 +225,7 @@ class TestPatch(api_base.FunctionalTest):
self.assertFalse(mock_upd.called)
def test_update_not_found(self, mock_upd):
uuid = utils.generate_uuid()
uuid = uuidutils.generate_uuid()
response = self.patch_json('/ports/%s' % uuid,
[{'path': '/extra/foo',
'value': 'bar',
@ -524,7 +524,7 @@ class TestPost(api_base.FunctionalTest):
response = self.post_json('/ports', pdict)
result = self.get_json('/ports/%s' % response.json['uuid'])
self.assertEqual(pdict['address'], result['address'])
self.assertTrue(utils.is_uuid_like(result['uuid']))
self.assertTrue(uuidutils.is_uuid_like(result['uuid']))
def test_create_port_valid_extra(self):
pdict = post_get_test_port(extra={'str': 'foo', 'int': 123,
@ -601,7 +601,7 @@ class TestPost(api_base.FunctionalTest):
address = 'AA:AA:AA:11:22:33'
pdict = post_get_test_port(address=address)
self.post_json('/ports', pdict)
pdict['uuid'] = utils.generate_uuid()
pdict['uuid'] = uuidutils.generate_uuid()
response = self.post_json('/ports', pdict, expect_errors=True)
self.assertEqual(409, response.status_int)
self.assertEqual('application/json', response.content_type)

5
ironic/tests/api/v1/test_types.py
View File

@ -16,6 +16,7 @@
# under the License.
import mock
from oslo_utils import uuidutils
import webtest
import wsme
from wsme import types as wtypes
@ -63,7 +64,7 @@ class TestNameType(base.TestCase):
class TestUuidOrNameType(base.TestCase):
@mock.patch.object(utils, 'is_uuid_like')
@mock.patch.object(uuidutils, 'is_uuid_like')
@mock.patch.object(utils, 'is_hostname_safe')
def test_valid_uuid(self, host_mock, uuid_mock):
test_uuid = '1a1a1a1a-2b2b-3c3c-4d4d-5e5e5e5e5e5e'
@ -72,7 +73,7 @@ class TestUuidOrNameType(base.TestCase):
self.assertTrue(types.UuidOrNameType.validate(test_uuid))
uuid_mock.assert_called_once_with(test_uuid)
@mock.patch.object(utils, 'is_uuid_like')
@mock.patch.object(uuidutils, 'is_uuid_like')
@mock.patch.object(utils, 'is_hostname_safe')
def test_valid_name(self, host_mock, uuid_mock):
test_name = 'dc16-database5'

24
ironic/tests/conductor/test_conductor_utils.py
View File

@ -11,11 +11,11 @@
# under the License.
import mock
from oslo_utils import uuidutils
from ironic.common import driver_factory
from ironic.common import exception
from ironic.common import states
from ironic.common import utils as cmn_utils
from ironic.conductor import task_manager
from ironic.conductor import utils as conductor_utils
from ironic import objects
@ -33,7 +33,7 @@ class NodeSetBootDeviceTestCase(base.DbTestCase):
self.driver = driver_factory.get_driver("fake_ipmitool")
ipmi_info = utils.get_test_ipmi_info()
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake_ipmitool',
driver_info=ipmi_info)
task = task_manager.TaskManager(self.context, node.uuid)
@ -47,7 +47,7 @@ class NodeSetBootDeviceTestCase(base.DbTestCase):
self.driver = driver_factory.get_driver("fake_ipmitool")
ipmi_info = utils.get_test_ipmi_info()
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake_ipmitool',
driver_info=ipmi_info)
task = task_manager.TaskManager(self.context, node.uuid)
@ -71,7 +71,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_power_on(self):
"""Test node_power_action to turn node power on."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
power_state=states.POWER_OFF)
task = task_manager.TaskManager(self.context, node.uuid)
@ -91,7 +91,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_power_off(self):
"""Test node_power_action to turn node power off."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
@ -111,7 +111,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_power_reboot(self):
"""Test for reboot a node."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
@ -128,7 +128,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_invalid_state(self):
"""Test for exception when changing to an invalid power state."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
@ -165,7 +165,7 @@ class NodePowerActionTestCase(base.DbTestCase):
and the user is attempting to power-off again.)
"""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON,
target_power_state=states.POWER_OFF)
@ -185,7 +185,7 @@ class NodePowerActionTestCase(base.DbTestCase):
state is the same as the current state.
"""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
last_error='anything but None',
power_state=states.POWER_ON)
@ -214,7 +214,7 @@ class NodePowerActionTestCase(base.DbTestCase):
information, make sure we fix it.
"""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
last_error='anything but None',
power_state=states.POWER_ON)
@ -239,7 +239,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_failed_getting_state(self):
"""Test for exception when we can't get the current power state."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
@ -263,7 +263,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_set_power_failure(self):
"""Test if an exception is thrown when the set_power call fails."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake',
power_state=states.POWER_OFF)
task = task_manager.TaskManager(self.context, node.uuid)

11
ironic/tests/conductor/test_manager.py
View File

@ -25,6 +25,8 @@ import mock
from oslo import messaging
from oslo_config import cfg
from oslo_db import exception as db_exception
from oslo_utils import strutils
from oslo_utils import uuidutils
from ironic.common import boot_devices
from ironic.common import driver_factory
@ -32,7 +34,6 @@ from ironic.common import exception
from ironic.common import keystone
from ironic.common import states
from ironic.common import swift
from ironic.common import utils as ironic_utils
from ironic.conductor import manager
from ironic.conductor import task_manager
from ironic.conductor import utils as conductor_utils
@ -53,7 +54,7 @@ class _CommonMixIn(object):
@staticmethod
def _create_node(**kwargs):
attrs = {'id': 1,
'uuid': ironic_utils.generate_uuid(),
'uuid': uuidutils.generate_uuid(),
'power_state': states.POWER_OFF,
'maintenance': False,
'reservation': None}
@ -127,7 +128,7 @@ class _CommonMixIn(object):
# NOTE(comstud): Not ideal to throw this into
# a helper, however it's the cleanest way
# to verify we're dealing with the correct task/node.
if ironic_utils.is_int_like(fa_self.node_id):
if strutils.is_int_like(fa_self.node_id):
self.assertEqual(fa_self.node_id, task.node.id)
else:
self.assertEqual(fa_self.node_id, task.node.uuid)
@ -1371,7 +1372,7 @@ class DoNodeDeployTearDownTestCase(_ServiceSetUpMixin,
def _test_do_node_tear_down_from_state(self, init_state, mock_tear_down):
mock_tear_down.return_value = states.DELETED
node = obj_utils.create_test_node(self.context, driver='fake',
uuid=ironic_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
provision_state=init_state,
target_provision_state=states.NOSTATE)
@ -2371,7 +2372,7 @@ class ManagerSyncPowerStatesTestCase(_CommonMixIn, tests_db_base.DbTestCase):
mapped_map = {}
for i in range(1, 12):
attrs = {'id': i,
'uuid': ironic_utils.generate_uuid()}
'uuid': uuidutils.generate_uuid()}
if i == 3:
attrs['provision_state'] = states.DEPLOYWAIT
attrs['target_provision_state'] = states.ACTIVE

4
ironic/tests/conductor/test_task_manager.py
View File

@ -20,12 +20,12 @@
import eventlet
from eventlet import greenpool
import mock
from oslo_utils import uuidutils
from ironic.common import driver_factory
from ironic.common import exception
from ironic.common import fsm
from ironic.common import states
from ironic.common import utils
from ironic.conductor import task_manager
from ironic import objects
from ironic.tests import base as tests_base
@ -89,7 +89,7 @@ class TaskManagerTestCase(tests_db_base.DbTestCase):
reserve_mock, release_mock,
node_get_mock):
node2 = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake')
reserve_mock.return_value = self.node

14
ironic/tests/db/sqlalchemy/test_migrations.py
View File

@ -48,11 +48,11 @@ from oslo_db import exception as db_exc
from oslo_db.sqlalchemy import test_base
from oslo_db.sqlalchemy import test_migrations
from oslo_db.sqlalchemy import utils as db_utils
from oslo_utils import uuidutils
import sqlalchemy
import sqlalchemy.exc
from ironic.common.i18n import _LE
from ironic.common import utils
from ironic.db.sqlalchemy import migration
from ironic.db.sqlalchemy import models
from ironic.openstack.common import log as logging
@ -310,10 +310,10 @@ class MigrationCheckersMixin(object):
nodes = db_utils.get_table(engine, 'nodes')
instance_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
data = {'driver': 'fake',
'uuid': utils.generate_uuid(),
'uuid': uuidutils.generate_uuid(),
'instance_uuid': instance_uuid}
nodes.insert().values(data).execute()
data['uuid'] = utils.generate_uuid()
data['uuid'] = uuidutils.generate_uuid()
# TODO(viktors): Remove check on sqlalchemy.exc.IntegrityError, when
# Ironic will use oslo_db 0.4.0 or higher.
# See bug #1214341 for details.
@ -332,13 +332,13 @@ class MigrationCheckersMixin(object):
# add some nodes in various states so we can assert that "None"
# was replaced by "available", and nothing else changed.
nodes = db_utils.get_table(engine, 'nodes')
data = [{'uuid': utils.generate_uuid(),
data = [{'uuid': uuidutils.generate_uuid(),
'provision_state': 'fake state'},
{'uuid': utils.generate_uuid(),
{'uuid': uuidutils.generate_uuid(),
'provision_state': 'active'},
{'uuid': utils.generate_uuid(),
{'uuid': uuidutils.generate_uuid(),
'provision_state': 'deleting'},
{'uuid': utils.generate_uuid(),
{'uuid': uuidutils.generate_uuid(),
'provision_state': None}]
nodes.insert().values(data).execute()
return data

6
ironic/tests/db/sqlalchemy/test_types.py
View File

@ -13,8 +13,8 @@
"""Tests for custom SQLAlchemy types via Ironic DB."""
from oslo_db import exception as db_exc
from oslo_utils import uuidutils
from ironic.common import utils as ironic_utils
import ironic.db.sqlalchemy.api as sa_api
from ironic.db.sqlalchemy import models
from ironic.tests.db import base
@ -27,14 +27,14 @@ class SqlAlchemyCustomTypesTestCase(base.DbTestCase):
def test_JSONEncodedDict_default_value(self):
# Create chassis w/o extra specified.
ch1_id = ironic_utils.generate_uuid()
ch1_id = uuidutils.generate_uuid()
self.dbapi.create_chassis({'uuid': ch1_id})
# Get chassis manually to test SA types in isolation from UOM.
ch1 = sa_api.model_query(models.Chassis).filter_by(uuid=ch1_id).one()
self.assertEqual({}, ch1.extra)
# Create chassis with extra specified.
ch2_id = ironic_utils.generate_uuid()
ch2_id = uuidutils.generate_uuid()
extra = {'foo1': 'test', 'foo2': 'other extra'}
self.dbapi.create_chassis({'uuid': ch2_id, 'extra': extra})
# Get chassis manually to test SA types in isolation from UOM.

6
ironic/tests/db/test_chassis.py
View File

@ -15,10 +15,10 @@
"""Tests for manipulating Chassis via the DB API"""
from oslo_utils import uuidutils
import six
from ironic.common import exception
from ironic.common import utils as ironic_utils
from ironic.tests.db import base
from ironic.tests.db import utils
@ -33,7 +33,7 @@ class DbChassisTestCase(base.DbTestCase):
def test_get_chassis_list(self):
uuids = []
for i in range(1, 6):
n = utils.get_test_chassis(id=i, uuid=ironic_utils.generate_uuid())
n = utils.get_test_chassis(id=i, uuid=uuidutils.generate_uuid())
self.dbapi.create_chassis(n)
uuids.append(six.text_type(n['uuid']))
res = self.dbapi.get_chassis_list()
@ -91,7 +91,7 @@ class DbChassisTestCase(base.DbTestCase):
self.dbapi.destroy_chassis, ch['id'])
def test_create_chassis_already_exists(self):
uuid = ironic_utils.generate_uuid()
uuid = uuidutils.generate_uuid()
self._create_test_chassis(id=1, uuid=uuid)
self.assertRaises(exception.ChassisAlreadyExists,
self._create_test_chassis,

56
ironic/tests/db/test_nodes.py
View File

@ -19,11 +19,11 @@ import datetime
import mock
from oslo_utils import timeutils
from oslo_utils import uuidutils
import six
from ironic.common import exception
from ironic.common import states
from ironic.common import utils as ironic_utils
from ironic.tests.db import base
from ironic.tests.db import utils
@ -42,12 +42,12 @@ class DbNodeTestCase(base.DbTestCase):
utils.create_test_node)
def test_create_node_instance_already_associated(self):
instance = ironic_utils.generate_uuid()
utils.create_test_node(uuid=ironic_utils.generate_uuid(),
instance = uuidutils.generate_uuid()
utils.create_test_node(uuid=uuidutils.generate_uuid(),
instance_uuid=instance)
self.assertRaises(exception.InstanceAssociated,
utils.create_test_node,
uuid=ironic_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
instance_uuid=instance)
def test_create_node_name_duplicate(self):
@ -88,7 +88,7 @@ class DbNodeTestCase(base.DbTestCase):
def test_get_nodeinfo_list_defaults(self):
node_id_list = []
for i in range(1, 6):
node = utils.create_test_node(uuid=ironic_utils.generate_uuid())
node = utils.create_test_node(uuid=uuidutils.generate_uuid())
node_id_list.append(node.id)
res = [i[0] for i in self.dbapi.get_nodeinfo_list()]
self.assertEqual(sorted(res), sorted(node_id_list))
@ -97,7 +97,7 @@ class DbNodeTestCase(base.DbTestCase):
uuids = {}
extras = {}
for i in range(1, 6):
uuid = ironic_utils.generate_uuid()
uuid = uuidutils.generate_uuid()
extra = {'foo': i}
node = utils.create_test_node(extra=extra, uuid=uuid)
uuids[node.id] = uuid
@ -108,11 +108,11 @@ class DbNodeTestCase(base.DbTestCase):
def test_get_nodeinfo_list_with_filters(self):
node1 = utils.create_test_node(driver='driver-one',
instance_uuid=ironic_utils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid(),
reservation='fake-host',
uuid=ironic_utils.generate_uuid())
uuid=uuidutils.generate_uuid())
node2 = utils.create_test_node(driver='driver-two',
uuid=ironic_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
maintenance=True)
res = self.dbapi.get_nodeinfo_list(filters={'driver': 'driver-one'})
@ -147,13 +147,13 @@ class DbNodeTestCase(base.DbTestCase):
mock_utcnow.return_value = past
# node with provision_updated timeout
node1 = utils.create_test_node(uuid=ironic_utils.generate_uuid(),
node1 = utils.create_test_node(uuid=uuidutils.generate_uuid(),
provision_updated_at=past)
# node with None in provision_updated_at
node2 = utils.create_test_node(uuid=ironic_utils.generate_uuid(),
node2 = utils.create_test_node(uuid=uuidutils.generate_uuid(),
provision_state=states.DEPLOYWAIT)
# node without timeout
utils.create_test_node(uuid=ironic_utils.generate_uuid(),
utils.create_test_node(uuid=uuidutils.generate_uuid(),
provision_updated_at=next)
mock_utcnow.return_value = present
@ -167,25 +167,25 @@ class DbNodeTestCase(base.DbTestCase):
def test_get_node_list(self):
uuids = []
for i in range(1, 6):
node = utils.create_test_node(uuid=ironic_utils.generate_uuid())
node = utils.create_test_node(uuid=uuidutils.generate_uuid())
uuids.append(six.text_type(node['uuid']))
res = self.dbapi.get_node_list()
res_uuids = [r.uuid for r in res]
self.assertEqual(uuids.sort(), res_uuids.sort())
def test_get_node_list_with_filters(self):
ch1 = utils.get_test_chassis(id=1, uuid=ironic_utils.generate_uuid())
ch2 = utils.get_test_chassis(id=2, uuid=ironic_utils.generate_uuid())
ch1 = utils.get_test_chassis(id=1, uuid=uuidutils.generate_uuid())
ch2 = utils.get_test_chassis(id=2, uuid=uuidutils.generate_uuid())
self.dbapi.create_chassis(ch1)
self.dbapi.create_chassis(ch2)
node1 = utils.create_test_node(driver='driver-one',
instance_uuid=ironic_utils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid(),
reservation='fake-host',
uuid=ironic_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
chassis_id=ch1['id'])
node2 = utils.create_test_node(driver='driver-two',
uuid=ironic_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
chassis_id=ch2['id'],
maintenance=True)
@ -222,7 +222,7 @@ class DbNodeTestCase(base.DbTestCase):
def test_get_node_list_chassis_not_found(self):
self.assertRaises(exception.ChassisNotFound,
self.dbapi.get_node_list,
{'chassis_uuid': ironic_utils.generate_uuid()})
{'chassis_uuid': uuidutils.generate_uuid()})
def test_get_node_by_instance(self):
node = utils.create_test_node(
@ -294,7 +294,7 @@ class DbNodeTestCase(base.DbTestCase):
self.assertEqual(new_extra, res.extra)
def test_update_node_not_found(self):
node_uuid = ironic_utils.generate_uuid()
node_uuid = uuidutils.generate_uuid()
new_extra = {'foo': 'bar'}
self.assertRaises(exception.NodeNotFound, self.dbapi.update_node,
node_uuid, {'extra': new_extra})
@ -307,7 +307,7 @@ class DbNodeTestCase(base.DbTestCase):
def test_update_node_associate_and_disassociate(self):
node = utils.create_test_node()
new_i_uuid = ironic_utils.generate_uuid()
new_i_uuid = uuidutils.generate_uuid()
res = self.dbapi.update_node(node.id, {'instance_uuid': new_i_uuid})
self.assertEqual(new_i_uuid, res.instance_uuid)
res = self.dbapi.update_node(node.id, {'instance_uuid': None})
@ -315,19 +315,19 @@ class DbNodeTestCase(base.DbTestCase):
def test_update_node_already_associated(self):
node = utils.create_test_node()
new_i_uuid_one = ironic_utils.generate_uuid()
new_i_uuid_one = uuidutils.generate_uuid()
self.dbapi.update_node(node.id, {'instance_uuid': new_i_uuid_one})
new_i_uuid_two = ironic_utils.generate_uuid()
new_i_uuid_two = uuidutils.generate_uuid()
self.assertRaises(exception.NodeAssociated,
self.dbapi.update_node,
node.id,
{'instance_uuid': new_i_uuid_two})
def test_update_node_instance_already_associated(self):
node1 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
new_i_uuid = ironic_utils.generate_uuid()
node1 = utils.create_test_node(uuid=uuidutils.generate_uuid())
new_i_uuid = uuidutils.generate_uuid()
self.dbapi.update_node(node1.id, {'instance_uuid': new_i_uuid})
node2 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
node2 = utils.create_test_node(uuid=uuidutils.generate_uuid())
self.assertRaises(exception.InstanceAssociated,
self.dbapi.update_node,
node2.id,
@ -343,9 +343,9 @@ class DbNodeTestCase(base.DbTestCase):
timeutils.normalize_time(res['provision_updated_at']))
def test_update_node_name_duplicate(self):
node1 = utils.create_test_node(uuid=ironic_utils.generate_uuid(),
node1 = utils.create_test_node(uuid=uuidutils.generate_uuid(),
name='spam')
node2 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
node2 = utils.create_test_node(uuid=uuidutils.generate_uuid())
self.assertRaises(exception.DuplicateName,
self.dbapi.update_node,
node2.id,

8
ironic/tests/db/test_ports.py
View File

@ -15,10 +15,10 @@
"""Tests for manipulating Ports via the DB API"""
from oslo_utils import uuidutils
import six
from ironic.common import exception
from ironic.common import utils as ironic_utils
from ironic.tests.db import base
from ironic.tests.db import utils as db_utils
@ -47,7 +47,7 @@ class DbPortTestCase(base.DbTestCase):
def test_get_port_list(self):
uuids = []
for i in range(1, 6):
port = db_utils.create_test_port(uuid=ironic_utils.generate_uuid(),
port = db_utils.create_test_port(uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:4%s' % i)
uuids.append(six.text_type(port.uuid))
res = self.dbapi.get_port_list()
@ -88,7 +88,7 @@ class DbPortTestCase(base.DbTestCase):
def test_update_port_duplicated_address(self):
address1 = self.port.address
address2 = 'aa-bb-cc-11-22-33'
port2 = db_utils.create_test_port(uuid=ironic_utils.generate_uuid(),
port2 = db_utils.create_test_port(uuid=uuidutils.generate_uuid(),
node_id=self.node.id,
address=address2)
self.assertRaises(exception.MACAlreadyExists,
@ -98,7 +98,7 @@ class DbPortTestCase(base.DbTestCase):
def test_create_port_duplicated_address(self):
self.assertRaises(exception.MACAlreadyExists,
db_utils.create_test_port,
uuid=ironic_utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
node_id=self.node.id,
address=self.port.address)

6
ironic/tests/dhcp/test_neutron.py
View File

@ -17,11 +17,11 @@
import mock
from neutronclient.common import exceptions as neutron_client_exc
from neutronclient.v2_0 import client
from oslo_utils import uuidutils
from ironic.common import dhcp_factory
from ironic.common import exception
from ironic.common import pxe_utils
from ironic.common import utils
from ironic.conductor import task_manager
from ironic.dhcp import neutron
from ironic.tests.conductor import utils as mgr_utils
@ -301,7 +301,7 @@ class TestNeutron(db_base.DbTestCase):
port = object_utils.create_test_port(self.context,
node_id=self.node.id,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
extra={'vif_port_id':
'test-vif-A'},
driver='fake')
@ -323,7 +323,7 @@ class TestNeutron(db_base.DbTestCase):
port = object_utils.create_test_port(self.context,
node_id=self.node.id,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
extra={'vif_port_id':
'test-vif-A'},
driver='fake')

3
ironic/tests/drivers/test_deploy_utils.py
View File

@ -25,6 +25,7 @@ import fixtures
import mock
from oslo_concurrency import processutils
from oslo_config import cfg
from oslo_utils import uuidutils
import requests
from ironic.common import disk_partitioner
@ -1094,7 +1095,7 @@ class VirtualMediaDeployUtilsTestCase(db_base.DbTestCase):
def test_get_single_nic_with_vif_port_id(self):
obj_utils.create_test_port(self.context, node_id=self.node.id,
address='aa:bb:cc', uuid=common_utils.generate_uuid(),
address='aa:bb:cc', uuid=uuidutils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'}, driver='iscsi_ilo')
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:

4
ironic/tests/drivers/test_ipminative.py
View File

@ -21,13 +21,13 @@ Test class for Native IPMI power driver module.
import mock
from oslo_config import cfg
from oslo_utils import uuidutils
from pyghmi import exceptions as pyghmi_exception
from ironic.common import boot_devices
from ironic.common import driver_factory
from ironic.common import exception
from ironic.common import states
from ironic.common import utils
from ironic.conductor import task_manager
from ironic.drivers.modules import console_utils
from ironic.drivers.modules import ipminative
@ -388,7 +388,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
def test_management_interface_validate_fail(self):
# Missing IPMI driver_info information
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake_ipminative')
with task_manager.acquire(self.context, node.uuid) as task:
self.assertRaises(exception.MissingParameterValue,

3
ironic/tests/drivers/test_ipmitool.py
View File

@ -28,6 +28,7 @@ import time
import mock
from oslo_concurrency import processutils
from oslo_config import cfg
from oslo_utils import uuidutils
from ironic.common import boot_devices
from ironic.common import driver_factory
@ -1317,7 +1318,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
def test_management_interface_validate_fail(self):
# Missing IPMI driver_info information
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake_ipmitool')
with task_manager.acquire(self.context, node.uuid) as task:
self.assertRaises(exception.MissingParameterValue,

5
ironic/tests/drivers/test_iscsi_deploy.py
View File

@ -20,6 +20,7 @@ import tempfile
import mock
from oslo_config import cfg
from oslo_utils import uuidutils
from ironic.common import exception
from ironic.common import keystone
@ -114,7 +115,7 @@ class IscsiDeployValidateParametersTestCase(db_base.DbTestCase):
'on', 'yes', 'y', '1']:
info['preserve_ephemeral'] = opt
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
instance_info=info)
data = iscsi_deploy.parse_instance_info(node)
self.assertTrue(data.get('preserve_ephemeral'))
@ -125,7 +126,7 @@ class IscsiDeployValidateParametersTestCase(db_base.DbTestCase):
'off', 'no', 'n', '0']:
info['preserve_ephemeral'] = opt
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
instance_info=info)
data = iscsi_deploy.parse_instance_info(node)
self.assertFalse(data.get('preserve_ephemeral'))

4
ironic/tests/drivers/test_seamicro.py
View File

@ -15,6 +15,7 @@
import uuid
import mock
from oslo_utils import uuidutils
from seamicroclient import client as seamicro_client
from seamicroclient import exceptions as seamicro_client_exception
@ -22,7 +23,6 @@ from ironic.common import boot_devices
from ironic.common import driver_factory
from ironic.common import exception
from ironic.common import states
from ironic.common import utils
from ironic.conductor import task_manager
from ironic.drivers.modules import console_utils
from ironic.drivers.modules import seamicro
@ -578,7 +578,7 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
def test_management_interface_validate_fail(self):
# Missing SEAMICRO driver_info information
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake_seamicro')
with task_manager.acquire(self.context, node.uuid) as task:
self.assertRaises(exception.MissingParameterValue,

3
ironic/tests/drivers/test_ssh.py
View File

@ -19,6 +19,7 @@ import fixtures
import mock
from oslo_concurrency import processutils
from oslo_config import cfg
from oslo_utils import uuidutils
import paramiko
from ironic.common import boot_devices
@ -947,7 +948,7 @@ class SSHDriverTestCase(db_base.DbTestCase):
def test_management_interface_validate_fail(self):
# Missing SSH driver_info information
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
driver='fake_ssh')
with task_manager.acquire(self.context, node.uuid) as task:
self.assertRaises(exception.MissingParameterValue,

4
ironic/tests/objects/test_chassis.py
View File

@ -14,10 +14,10 @@
# under the License.
import mock
from oslo_utils import uuidutils
from testtools.matchers import HasLength
from ironic.common import exception
from ironic.common import utils as ironic_utils
from ironic import objects
from ironic.tests.db import base
from ironic.tests.db import utils
@ -74,7 +74,7 @@ class TestChassisObject(base.DbTestCase):
def test_refresh(self):
uuid = self.fake_chassis['uuid']
new_uuid = ironic_utils.generate_uuid()
new_uuid = uuidutils.generate_uuid()
returns = [dict(self.fake_chassis, uuid=uuid),
dict(self.fake_chassis, uuid=new_uuid)]
expected = [mock.call(uuid), mock.call(uuid)]

9
ironic/tests/test_network.py
View File

@ -13,8 +13,9 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo_utils import uuidutils
from ironic.common import network
from ironic.common import utils
from ironic.conductor import task_manager
from ironic.tests.conductor import utils as mgr_utils
from ironic.tests.db import base as db_base
@ -38,7 +39,7 @@ class TestNetwork(db_base.DbTestCase):
def test_get_node_vif_ids_one_port(self):
port1 = db_utils.create_test_port(node_id=self.node.id,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'},
driver='fake')
expected = {port1.uuid: 'test-vif-A'}
@ -49,12 +50,12 @@ class TestNetwork(db_base.DbTestCase):
def test_get_node_vif_ids_two_ports(self):
port1 = db_utils.create_test_port(node_id=self.node.id,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'},
driver='fake')
port2 = db_utils.create_test_port(node_id=self.node.id,
address='dd:ee:ff',
uuid=utils.generate_uuid(),
uuid=uuidutils.generate_uuid(),
extra={'vif_port_id': 'test-vif-B'},
driver='fake')
expected = {port1.uuid: 'test-vif-A', port2.uuid: 'test-vif-B'}

41
ironic/tests/test_utils.py
View File

@ -19,7 +19,6 @@ import os
import os.path
import shutil
import tempfile
import uuid
import mock
import netaddr
@ -443,46 +442,6 @@ class MkfsTestCase(base.TestCase):
'ext4', '/my/block/dev', 'ext4-vol')
class IntLikeTestCase(base.TestCase):
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 UUIDTestCase(base.TestCase):
def test_generate_uuid(self):
uuid_string = utils.generate_uuid()
self.assertIsInstance(uuid_string, str)
self.assertEqual(36, len(uuid_string))
# make sure there are 4 dashes
self.assertEqual(32, len(uuid_string.replace('-', '')))
def test_is_uuid_like(self):
self.assertTrue(utils.is_uuid_like(str(uuid.uuid4())))
def test_id_is_uuid_like(self):
self.assertFalse(utils.is_uuid_like(1234567))
def test_name_is_uuid_like(self):
self.assertFalse(utils.is_uuid_like('zhongyueluo'))
class TempFilesTestCase(base.TestCase):
def test_tempdir(self):