openstack/ironic
Code Issues Proposed changes

Use functions from oslo.utils

Browse Source 
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 import datetime
from oslo_config import cfg from oslo_config import cfg
from oslo_utils import uuidutils
import pecan import pecan
from pecan import rest from pecan import rest
import wsme import wsme
@ -88,7 +89,7 @@ def allow_logical_names():
def is_valid_name(name): 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): 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 # Check to see if the node_ident is a valid UUID. If it is, treat it
# as a UUID. # 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) 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, # 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: if node:
# We're invoking this interface using positional notation, or # We're invoking this interface using positional notation, or
# explicitly using 'node'. Try and determine which one. # 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() raise exception.NotAcceptable()
rpc_node = _get_rpc_node(node_uuid or node) 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 # We need to ensure that node has a UUID before it can
# be mapped onto the hash ring. # be mapped onto the hash ring.
if not node.uuid: if not node.uuid:
node.uuid = utils.generate_uuid() node.uuid = uuidutils.generate_uuid()
try: try:
pecan.request.rpcapi.get_topic_for(node) pecan.request.rpcapi.get_topic_for(node)

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

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

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

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

26
ironic/common/utils.py
View File

@ -26,7 +26,6 @@ import random
import re import re
import shutil import shutil
import tempfile import tempfile
import uuid
import netaddr import netaddr
from oslo_concurrency import processutils from oslo_concurrency import processutils
@ -157,14 +156,6 @@ def delete_if_exists(pathname):
raise 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): def is_valid_boolstr(val):
"""Check if the provided string is a valid bool string or not.""" """Check if the provided string is a valid bool string or not."""
boolstrs = ('true', 'false', 'yes', 'no', 'y', 'n', '1', '0') 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 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): def mount(src, dest, *args):
"""Mounts a device/image file on specified location. """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_config import cfg
from oslo_db import exception as db_exception from oslo_db import exception as db_exception
from oslo_utils import excutils from oslo_utils import excutils
from oslo_utils import uuidutils
from ironic.common import dhcp_factory from ironic.common import dhcp_factory
from ironic.common import driver_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 rpc
from ironic.common import states from ironic.common import states
from ironic.common import swift from ironic.common import swift
from ironic.common import utils as ironic_utils
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic.conductor import utils from ironic.conductor import utils
from ironic.db import api as dbapi from ironic.db import api as dbapi
@ -1210,7 +1210,7 @@ class ConductorManager(periodic_task.PeriodicTasks):
continue continue
# populate the message which will be sent to ceilometer # 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, 'instance_uuid': instance_uuid,
'node_uuid': node_uuid, 'node_uuid': node_uuid,
'timestamp': datetime.datetime.utcnow(), '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, 'instance_uuid': None,
'power_state': states.POWER_OFF, 'power_state': states.POWER_OFF,
'provision_state': states.AVAILABLE, '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 import exception as db_exc
from oslo_db.sqlalchemy import session as db_session from oslo_db.sqlalchemy import session as db_session
from oslo_db.sqlalchemy import utils as db_utils from oslo_db.sqlalchemy import utils as db_utils
from oslo_utils import strutils
from oslo_utils import timeutils from oslo_utils import timeutils
from oslo_utils import uuidutils
from sqlalchemy.orm.exc import NoResultFound from sqlalchemy.orm.exc import NoResultFound
from ironic.common import exception from ironic.common import exception
@ -89,9 +91,9 @@ def add_identity_filter(query, value):
:param value: Value for filtering results by. :param value: Value for filtering results by.
:return: Modified query. :return: Modified query.
""" """
if utils.is_int_like(value): if strutils.is_int_like(value):
return query.filter_by(id=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) return query.filter_by(uuid=value)
else: else:
raise exception.InvalidIdentity(identity=value) raise exception.InvalidIdentity(identity=value)
@ -114,7 +116,7 @@ def add_port_filter(query, value):
def add_port_filter_by_node(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) return query.filter_by(node_id=value)
else: else:
query = query.join(models.Node, 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): 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) return query.filter_by(chassis_id=value)
else: else:
query = query.join(models.Chassis, query = query.join(models.Chassis,
@ -254,7 +256,7 @@ class Connection(api.Connection):
def create_node(self, values): def create_node(self, values):
# ensure defaults are present for new nodes # ensure defaults are present for new nodes
if 'uuid' not in values: if 'uuid' not in values:
values['uuid'] = utils.generate_uuid() values['uuid'] = uuidutils.generate_uuid()
if 'power_state' not in values: if 'power_state' not in values:
values['power_state'] = states.NOSTATE values['power_state'] = states.NOSTATE
if 'provision_state' not in values: if 'provision_state' not in values:
@ -297,7 +299,7 @@ class Connection(api.Connection):
raise exception.NodeNotFound(node=node_name) raise exception.NodeNotFound(node=node_name)
def get_node_by_instance(self, instance): 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) raise exception.InvalidUUID(uuid=instance)
query = (model_query(models.Node) query = (model_query(models.Node)
@ -323,7 +325,7 @@ class Connection(api.Connection):
# Get node ID, if an UUID was supplied. The ID is # Get node ID, if an UUID was supplied. The ID is
# required for deleting all ports, attached to the node. # 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'] node_id = node_ref['id']
port_query = model_query(models.Port, session=session) port_query = model_query(models.Port, session=session)
@ -408,7 +410,7 @@ class Connection(api.Connection):
def create_port(self, values): def create_port(self, values):
if not values.get('uuid'): if not values.get('uuid'):
values['uuid'] = utils.generate_uuid() values['uuid'] = uuidutils.generate_uuid()
port = models.Port() port = models.Port()
port.update(values) port.update(values)
try: try:
@ -473,7 +475,7 @@ class Connection(api.Connection):
def create_chassis(self, values): def create_chassis(self, values):
if not values.get('uuid'): if not values.get('uuid'):
values['uuid'] = utils.generate_uuid() values['uuid'] = uuidutils.generate_uuid()
chassis = models.Chassis() chassis = models.Chassis()
chassis.update(values) chassis.update(values)
try: try:

4
ironic/migrate_nova/migrate_db.py
View File

@ -15,11 +15,11 @@ import ConfigParser
import os import os
import sys import sys
from oslo_utils import uuidutils
import sqlalchemy as sa import sqlalchemy as sa
from sqlalchemy.orm import sessionmaker from sqlalchemy.orm import sessionmaker
from ironic.common import states as ironic_states from ironic.common import states as ironic_states
from ironic.common import utils
from ironic.db.sqlalchemy import models as ironic_models 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_baremetal_states as nova_states
from ironic.migrate_nova import nova_models from ironic.migrate_nova import nova_models
@ -186,7 +186,7 @@ def convert_nova_ports(ports):
i_port = ironic_models.Port() i_port = ironic_models.Port()
i_port.id = n_port.id 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.address = n_port.address
i_port.node_id = n_port.bm_node_id 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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_utils import strutils
from oslo_utils import uuidutils
from ironic.common import exception from ironic.common import exception
from ironic.common import utils
from ironic.db import api as dbapi from ironic.db import api as dbapi
from ironic.objects import base from ironic.objects import base
from ironic.objects import utils as obj_utils 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. :param chassis_id: the id *or* uuid of a chassis.
:returns: a :class:`Chassis` object. :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) 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) return cls.get_by_uuid(context, chassis_id)
else: else:
raise exception.InvalidIdentity(identity=chassis_id) 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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_utils import strutils
from oslo_utils import uuidutils
from ironic.common import exception from ironic.common import exception
from ironic.common import utils
from ironic.db import api as db_api from ironic.db import api as db_api
from ironic.objects import base from ironic.objects import base
from ironic.objects import utils as obj_utils 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. :param node_id: the id *or* uuid of a node.
:returns: a :class:`Node` object. :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) 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) return cls.get_by_uuid(context, node_id)
else: else:
raise exception.InvalidIdentity(identity=node_id) 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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_utils import strutils
from oslo_utils import uuidutils
from ironic.common import exception from ironic.common import exception
from ironic.common import utils from ironic.common import utils
from ironic.db import api as dbapi 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. :param port_id: the id *or* uuid of a port.
:returns: a :class:`Port` object. :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) 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) return cls.get_by_uuid(context, port_id)
elif utils.is_valid_mac(port_id): elif utils.is_valid_mac(port_id):
return cls.get_by_address(context, 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 import mock
from oslo_config import cfg from oslo_config import cfg
from oslo_utils import timeutils from oslo_utils import timeutils
from oslo_utils import uuidutils
from six.moves.urllib import parse as urlparse from six.moves.urllib import parse as urlparse
from wsme import types as wtypes from wsme import types as wtypes
from ironic.api.controllers.v1 import chassis as api_chassis 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 base as api_base
from ironic.tests.api import utils as apiutils from ironic.tests.api import utils as apiutils
from ironic.tests import base from ironic.tests import base
@ -76,8 +76,8 @@ class TestListChassis(api_base.FunctionalTest):
def test_many(self): def test_many(self):
ch_list = [] ch_list = []
for id_ in range(5): for id_ in range(5):
chassis = obj_utils.create_test_chassis(self.context, id=id_, chassis = obj_utils.create_test_chassis(
uuid=utils.generate_uuid()) self.context, id=id_, uuid=uuidutils.generate_uuid())
ch_list.append(chassis.uuid) ch_list.append(chassis.uuid)
data = self.get_json('/chassis') data = self.get_json('/chassis')
self.assertEqual(len(ch_list), len(data['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()) self.assertEqual(ch_list.sort(), uuids.sort())
def test_links(self): def test_links(self):
uuid = utils.generate_uuid() uuid = uuidutils.generate_uuid()
obj_utils.create_test_chassis(self.context, id=1, uuid=uuid) obj_utils.create_test_chassis(self.context, id=1, uuid=uuid)
data = self.get_json('/chassis/%s' % uuid) data = self.get_json('/chassis/%s' % uuid)
self.assertIn('links', data.keys()) self.assertIn('links', data.keys())
@ -98,7 +98,7 @@ class TestListChassis(api_base.FunctionalTest):
def test_collection_links(self): def test_collection_links(self):
for id in range(5): for id in range(5):
obj_utils.create_test_chassis(self.context, id=id, obj_utils.create_test_chassis(self.context, id=id,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
data = self.get_json('/chassis/?limit=3') data = self.get_json('/chassis/?limit=3')
self.assertEqual(3, len(data['chassis'])) self.assertEqual(3, len(data['chassis']))
@ -109,7 +109,7 @@ class TestListChassis(api_base.FunctionalTest):
cfg.CONF.set_override('max_limit', 3, 'api') cfg.CONF.set_override('max_limit', 3, 'api')
for id_ in range(5): for id_ in range(5):
obj_utils.create_test_chassis(self.context, id=id_, obj_utils.create_test_chassis(self.context, id=id_,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
data = self.get_json('/chassis') data = self.get_json('/chassis')
self.assertEqual(3, len(data['chassis'])) self.assertEqual(3, len(data['chassis']))
@ -127,7 +127,7 @@ class TestListChassis(api_base.FunctionalTest):
for id_ in range(2): for id_ in range(2):
obj_utils.create_test_node(self.context, obj_utils.create_test_node(self.context,
chassis_id=chassis.id, chassis_id=chassis.id,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
data = self.get_json('/chassis/%s/nodes' % chassis.uuid) data = self.get_json('/chassis/%s/nodes' % chassis.uuid)
self.assertEqual(2, len(data['nodes'])) self.assertEqual(2, len(data['nodes']))
@ -156,7 +156,7 @@ class TestPatch(api_base.FunctionalTest):
obj_utils.create_test_chassis(self.context) obj_utils.create_test_chassis(self.context)
def test_update_not_found(self): def test_update_not_found(self):
uuid = utils.generate_uuid() uuid = uuidutils.generate_uuid()
response = self.patch_json('/chassis/%s' % uuid, response = self.patch_json('/chassis/%s' % uuid,
[{'path': '/extra/a', 'value': 'b', [{'path': '/extra/a', 'value': 'b',
'op': 'add'}], 'op': 'add'}],
@ -186,7 +186,7 @@ class TestPatch(api_base.FunctionalTest):
def test_replace_multi(self): def test_replace_multi(self):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"} extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
chassis = obj_utils.create_test_chassis(self.context, extra=extra, chassis = obj_utils.create_test_chassis(self.context, extra=extra,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
id=1) id=1)
new_value = 'new value' new_value = 'new value'
response = self.patch_json('/chassis/%s' % chassis.uuid, response = self.patch_json('/chassis/%s' % chassis.uuid,
@ -201,7 +201,7 @@ class TestPatch(api_base.FunctionalTest):
def test_remove_singular(self): def test_remove_singular(self):
chassis = obj_utils.create_test_chassis(self.context, extra={'a': 'b'}, chassis = obj_utils.create_test_chassis(self.context, extra={'a': 'b'},
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
id=1) id=1)
response = self.patch_json('/chassis/%s' % chassis.uuid, response = self.patch_json('/chassis/%s' % chassis.uuid,
[{'path': '/description', 'op': 'remove'}]) [{'path': '/description', 'op': 'remove'}])
@ -218,7 +218,7 @@ class TestPatch(api_base.FunctionalTest):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"} extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
chassis = obj_utils.create_test_chassis(self.context, extra=extra, chassis = obj_utils.create_test_chassis(self.context, extra=extra,
description="foobar", description="foobar",
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
id=1) id=1)
# Removing one item from the collection # Removing one item from the collection
@ -339,7 +339,7 @@ class TestPost(api_base.FunctionalTest):
result = self.get_json('/chassis') result = self.get_json('/chassis')
self.assertEqual(cdict['description'], self.assertEqual(cdict['description'],
result['chassis'][0]['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): def test_post_nodes_subresource(self):
chassis = obj_utils.create_test_chassis(self.context) 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']) self.assertIn(chassis.uuid, response.json['error_message'])
def test_delete_chassis_not_found(self): def test_delete_chassis_not_found(self):
uuid = utils.generate_uuid() uuid = uuidutils.generate_uuid()
response = self.delete('/chassis/%s' % uuid, expect_errors=True) response = self.delete('/chassis/%s' % uuid, expect_errors=True)
self.assertEqual(404, response.status_int) self.assertEqual(404, response.status_int)
self.assertEqual('application/json', response.content_type) self.assertEqual('application/json', response.content_type)

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

@ -21,6 +21,7 @@ import json
import mock import mock
from oslo_config import cfg from oslo_config import cfg
from oslo_utils import timeutils from oslo_utils import timeutils
from oslo_utils import uuidutils
import pecan import pecan
from six.moves.urllib import parse as urlparse from six.moves.urllib import parse as urlparse
from testtools.matchers import HasLength 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 boot_devices
from ironic.common import exception from ironic.common import exception
from ironic.common import states from ironic.common import states
from ironic.common import utils
from ironic.conductor import rpcapi from ironic.conductor import rpcapi
from ironic import objects from ironic import objects
from ironic.tests.api import base as test_api_base from ironic.tests.api import base as test_api_base
@ -57,7 +57,7 @@ class TestTopLevelFunctions(base.TestCase):
def setUp(self): def setUp(self):
super(TestTopLevelFunctions, self).setUp() super(TestTopLevelFunctions, self).setUp()
self.valid_name = 'my-host' self.valid_name = 'my-host'
self.valid_uuid = utils.generate_uuid() self.valid_uuid = uuidutils.generate_uuid()
self.invalid_name = 'Mr Plow' self.invalid_name = 'Mr Plow'
self.invalid_uuid = '636-555-3226-' self.invalid_uuid = '636-555-3226-'
self.node = post_get_test_node() self.node = post_get_test_node()
@ -141,15 +141,15 @@ class TestListNodes(test_api_base.FunctionalTest):
unassociated_nodes = [] unassociated_nodes = []
for id in range(3): for id in range(3):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
unassociated_nodes.append(node.uuid) unassociated_nodes.append(node.uuid)
# created some associated nodes # created some associated nodes
associated_nodes = [] associated_nodes = []
for id in range(4): for id in range(4):
node = obj_utils.create_test_node( node = obj_utils.create_test_node(
self.context, uuid=utils.generate_uuid(), self.context, uuid=uuidutils.generate_uuid(),
instance_uuid=utils.generate_uuid()) instance_uuid=uuidutils.generate_uuid())
associated_nodes.append(node.uuid) associated_nodes.append(node.uuid)
return {'associated': associated_nodes, return {'associated': associated_nodes,
'unassociated': unassociated_nodes} 'unassociated': unassociated_nodes}
@ -266,7 +266,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = [] nodes = []
for id in range(5): for id in range(5):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
nodes.append(node.uuid) nodes.append(node.uuid)
data = self.get_json('/nodes') data = self.get_json('/nodes')
self.assertEqual(len(nodes), len(data['nodes'])) self.assertEqual(len(nodes), len(data['nodes']))
@ -280,7 +280,7 @@ class TestListNodes(test_api_base.FunctionalTest):
for id in range(5): for id in range(5):
name = 'node-%s' % id name = 'node-%s' % id
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
name=name) name=name)
nodes.append(node.uuid) nodes.append(node.uuid)
node_names.append(name) node_names.append(name)
@ -291,7 +291,7 @@ class TestListNodes(test_api_base.FunctionalTest):
self.assertEqual(sorted(node_names), sorted(names)) self.assertEqual(sorted(node_names), sorted(names))
def test_links(self): def test_links(self):
uuid = utils.generate_uuid() uuid = uuidutils.generate_uuid()
obj_utils.create_test_node(self.context, uuid=uuid) obj_utils.create_test_node(self.context, uuid=uuid)
data = self.get_json('/nodes/%s' % uuid) data = self.get_json('/nodes/%s' % uuid)
self.assertIn('links', data.keys()) self.assertIn('links', data.keys())
@ -305,7 +305,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = [] nodes = []
for id in range(5): for id in range(5):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
nodes.append(node.uuid) nodes.append(node.uuid)
data = self.get_json('/nodes/?limit=3') data = self.get_json('/nodes/?limit=3')
self.assertEqual(3, len(data['nodes'])) self.assertEqual(3, len(data['nodes']))
@ -318,7 +318,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = [] nodes = []
for id in range(5): for id in range(5):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
nodes.append(node.uuid) nodes.append(node.uuid)
data = self.get_json('/nodes') data = self.get_json('/nodes')
self.assertEqual(3, len(data['nodes'])) self.assertEqual(3, len(data['nodes']))
@ -336,7 +336,7 @@ class TestListNodes(test_api_base.FunctionalTest):
for id_ in range(2): for id_ in range(2):
obj_utils.create_test_port(self.context, node_id=node.id, 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_) address='52:54:00:cf:2d:3%s' % id_)
data = self.get_json('/nodes/%s/ports' % node.uuid) data = self.get_json('/nodes/%s/ports' % node.uuid)
@ -412,9 +412,10 @@ class TestListNodes(test_api_base.FunctionalTest):
self.assertFalse(data['console_enabled']) self.assertFalse(data['console_enabled'])
def test_node_by_instance_uuid(self): def test_node_by_instance_uuid(self):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(
uuid=utils.generate_uuid(), self.context,
instance_uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid())
instance_uuid = node.instance_uuid instance_uuid = node.instance_uuid
data = self.get_json('/nodes?instance_uuid=%s' % 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"]) data['nodes'][0]["instance_uuid"])
def test_node_by_instance_uuid_wrong_uuid(self): def test_node_by_instance_uuid_wrong_uuid(self):
obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(), obj_utils.create_test_node(
instance_uuid=utils.generate_uuid()) self.context, uuid=uuidutils.generate_uuid(),
wrong_uuid = utils.generate_uuid() instance_uuid=uuidutils.generate_uuid())
wrong_uuid = uuidutils.generate_uuid()
data = self.get_json('/nodes?instance_uuid=%s' % wrong_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']) self.assertIn('associated=True', data['next'])
def test_detail_with_instance_uuid(self): def test_detail_with_instance_uuid(self):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(
uuid=utils.generate_uuid(), self.context,
instance_uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid(),
instance_uuid=uuidutils.generate_uuid())
instance_uuid = node.instance_uuid instance_uuid = node.instance_uuid
data = self.get_json('/nodes/detail?instance_uuid=%s' % instance_uuid) data = self.get_json('/nodes/detail?instance_uuid=%s' % instance_uuid)
@ -526,7 +529,7 @@ class TestListNodes(test_api_base.FunctionalTest):
nodes = [] nodes = []
for id in range(5): for id in range(5):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
maintenance=id % 2) maintenance=id % 2)
nodes.append(node) nodes.append(node)
@ -549,8 +552,9 @@ class TestListNodes(test_api_base.FunctionalTest):
def test_maintenance_nodes_associated(self): def test_maintenance_nodes_associated(self):
self._create_association_test_nodes() self._create_association_test_nodes()
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(
instance_uuid=utils.generate_uuid(), self.context,
instance_uuid=uuidutils.generate_uuid(),
maintenance=True) maintenance=True)
data = self.get_json('/nodes?associated=true&maintenance=false') data = self.get_json('/nodes?associated=true&maintenance=false')
@ -884,7 +888,7 @@ class TestPatch(test_api_base.FunctionalTest):
def test_update_state_in_progress(self): def test_update_state_in_progress(self):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
target_power_state=states.POWER_OFF) target_power_state=states.POWER_OFF)
response = self.patch_json('/nodes/%s' % node.uuid, response = self.patch_json('/nodes/%s' % node.uuid,
[{'path': '/extra/foo', 'value': 'bar', [{'path': '/extra/foo', 'value': 'bar',
@ -895,7 +899,7 @@ class TestPatch(test_api_base.FunctionalTest):
def test_add_state_in_deployfail(self): def test_add_state_in_deployfail(self):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
provision_state=states.DEPLOYFAIL, provision_state=states.DEPLOYFAIL,
target_provision_state=states.ACTIVE) target_provision_state=states.ACTIVE)
self.mock_update_node.return_value = node self.mock_update_node.return_value = node
@ -1097,7 +1101,7 @@ class TestPatch(test_api_base.FunctionalTest):
def test_patch_duplicate_name(self): def test_patch_duplicate_name(self):
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid()) uuid=uuidutils.generate_uuid())
test_name = "this-is-my-node" test_name = "this-is-my-node"
self.mock_update_node.side_effect = exception.DuplicateName(test_name) self.mock_update_node.side_effect = exception.DuplicateName(test_name)
response = self.patch_json('/nodes/%s' % node.uuid, 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 import mock
from oslo_config import cfg from oslo_config import cfg
from oslo_utils import timeutils from oslo_utils import timeutils
from oslo_utils import uuidutils
from six.moves.urllib import parse as urlparse from six.moves.urllib import parse as urlparse
from testtools.matchers import HasLength from testtools.matchers import HasLength
from wsme import types as wtypes from wsme import types as wtypes
from ironic.api.controllers.v1 import port as api_port from ironic.api.controllers.v1 import port as api_port
from ironic.common import exception from ironic.common import exception
from ironic.common import utils
from ironic.conductor import rpcapi from ironic.conductor import rpcapi
from ironic.tests.api import base as api_base from ironic.tests.api import base as api_base
from ironic.tests.api import utils as apiutils from ironic.tests.api import utils as apiutils
@ -102,7 +102,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(5): for id_ in range(5):
port = obj_utils.create_test_port(self.context, port = obj_utils.create_test_port(self.context,
node_id=self.node.id, node_id=self.node.id,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_) address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid) ports.append(port.uuid)
data = self.get_json('/ports') data = self.get_json('/ports')
@ -112,7 +112,7 @@ class TestListPorts(api_base.FunctionalTest):
self.assertEqual(ports.sort(), uuids.sort()) self.assertEqual(ports.sort(), uuids.sort())
def test_links(self): def test_links(self):
uuid = utils.generate_uuid() uuid = uuidutils.generate_uuid()
obj_utils.create_test_port(self.context, obj_utils.create_test_port(self.context,
uuid=uuid, uuid=uuid,
node_id=self.node.id) node_id=self.node.id)
@ -129,7 +129,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(5): for id_ in range(5):
port = obj_utils.create_test_port(self.context, port = obj_utils.create_test_port(self.context,
node_id=self.node.id, node_id=self.node.id,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_) address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid) ports.append(port.uuid)
data = self.get_json('/ports/?limit=3') data = self.get_json('/ports/?limit=3')
@ -144,7 +144,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(5): for id_ in range(5):
port = obj_utils.create_test_port(self.context, port = obj_utils.create_test_port(self.context,
node_id=self.node.id, node_id=self.node.id,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_) address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid) ports.append(port.uuid)
data = self.get_json('/ports') data = self.get_json('/ports')
@ -158,7 +158,7 @@ class TestListPorts(api_base.FunctionalTest):
for id_ in range(3): for id_ in range(3):
obj_utils.create_test_port(self.context, obj_utils.create_test_port(self.context,
node_id=self.node.id, node_id=self.node.id,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
address=address_template % id_) address=address_template % id_)
target_address = address_template % 1 target_address = address_template % 1
@ -225,7 +225,7 @@ class TestPatch(api_base.FunctionalTest):
self.assertFalse(mock_upd.called) self.assertFalse(mock_upd.called)
def test_update_not_found(self, mock_upd): def test_update_not_found(self, mock_upd):
uuid = utils.generate_uuid() uuid = uuidutils.generate_uuid()
response = self.patch_json('/ports/%s' % uuid, response = self.patch_json('/ports/%s' % uuid,
[{'path': '/extra/foo', [{'path': '/extra/foo',
'value': 'bar', 'value': 'bar',
@ -524,7 +524,7 @@ class TestPost(api_base.FunctionalTest):
response = self.post_json('/ports', pdict) response = self.post_json('/ports', pdict)
result = self.get_json('/ports/%s' % response.json['uuid']) result = self.get_json('/ports/%s' % response.json['uuid'])
self.assertEqual(pdict['address'], result['address']) 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): def test_create_port_valid_extra(self):
pdict = post_get_test_port(extra={'str': 'foo', 'int': 123, 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' address = 'AA:AA:AA:11:22:33'
pdict = post_get_test_port(address=address) pdict = post_get_test_port(address=address)
self.post_json('/ports', pdict) self.post_json('/ports', pdict)
pdict['uuid'] = utils.generate_uuid() pdict['uuid'] = uuidutils.generate_uuid()
response = self.post_json('/ports', pdict, expect_errors=True) response = self.post_json('/ports', pdict, expect_errors=True)
self.assertEqual(409, response.status_int) self.assertEqual(409, response.status_int)
self.assertEqual('application/json', response.content_type) self.assertEqual('application/json', response.content_type)

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

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

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

@ -11,11 +11,11 @@
# under the License. # under the License.
import mock import mock
from oslo_utils import uuidutils
from ironic.common import driver_factory from ironic.common import driver_factory
from ironic.common import exception from ironic.common import exception
from ironic.common import states from ironic.common import states
from ironic.common import utils as cmn_utils
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic.conductor import utils as conductor_utils from ironic.conductor import utils as conductor_utils
from ironic import objects from ironic import objects
@ -33,7 +33,7 @@ class NodeSetBootDeviceTestCase(base.DbTestCase):
self.driver = driver_factory.get_driver("fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool")
ipmi_info = utils.get_test_ipmi_info() ipmi_info = utils.get_test_ipmi_info()
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake_ipmitool', driver='fake_ipmitool',
driver_info=ipmi_info) driver_info=ipmi_info)
task = task_manager.TaskManager(self.context, node.uuid) task = task_manager.TaskManager(self.context, node.uuid)
@ -47,7 +47,7 @@ class NodeSetBootDeviceTestCase(base.DbTestCase):
self.driver = driver_factory.get_driver("fake_ipmitool") self.driver = driver_factory.get_driver("fake_ipmitool")
ipmi_info = utils.get_test_ipmi_info() ipmi_info = utils.get_test_ipmi_info()
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake_ipmitool', driver='fake_ipmitool',
driver_info=ipmi_info) driver_info=ipmi_info)
task = task_manager.TaskManager(self.context, node.uuid) task = task_manager.TaskManager(self.context, node.uuid)
@ -71,7 +71,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_power_on(self): def test_node_power_action_power_on(self):
"""Test node_power_action to turn node power on.""" """Test node_power_action to turn node power on."""
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
power_state=states.POWER_OFF) power_state=states.POWER_OFF)
task = task_manager.TaskManager(self.context, node.uuid) task = task_manager.TaskManager(self.context, node.uuid)
@ -91,7 +91,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_power_off(self): def test_node_power_action_power_off(self):
"""Test node_power_action to turn node power off.""" """Test node_power_action to turn node power off."""
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
power_state=states.POWER_ON) power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid) task = task_manager.TaskManager(self.context, node.uuid)
@ -111,7 +111,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_power_reboot(self): def test_node_power_action_power_reboot(self):
"""Test for reboot a node.""" """Test for reboot a node."""
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
power_state=states.POWER_ON) power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid) task = task_manager.TaskManager(self.context, node.uuid)
@ -128,7 +128,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_invalid_state(self): def test_node_power_action_invalid_state(self):
"""Test for exception when changing to an invalid power state.""" """Test for exception when changing to an invalid power state."""
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
power_state=states.POWER_ON) power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid) 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.) and the user is attempting to power-off again.)
""" """
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
power_state=states.POWER_ON, power_state=states.POWER_ON,
target_power_state=states.POWER_OFF) target_power_state=states.POWER_OFF)
@ -185,7 +185,7 @@ class NodePowerActionTestCase(base.DbTestCase):
state is the same as the current state. state is the same as the current state.
""" """
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
last_error='anything but None', last_error='anything but None',
power_state=states.POWER_ON) power_state=states.POWER_ON)
@ -214,7 +214,7 @@ class NodePowerActionTestCase(base.DbTestCase):
information, make sure we fix it. information, make sure we fix it.
""" """
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
last_error='anything but None', last_error='anything but None',
power_state=states.POWER_ON) power_state=states.POWER_ON)
@ -239,7 +239,7 @@ class NodePowerActionTestCase(base.DbTestCase):
def test_node_power_action_failed_getting_state(self): def test_node_power_action_failed_getting_state(self):
"""Test for exception when we can't get the current power state.""" """Test for exception when we can't get the current power state."""
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
power_state=states.POWER_ON) power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid) 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): def test_node_power_action_set_power_failure(self):
"""Test if an exception is thrown when the set_power call fails.""" """Test if an exception is thrown when the set_power call fails."""
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake', driver='fake',
power_state=states.POWER_OFF) power_state=states.POWER_OFF)
task = task_manager.TaskManager(self.context, node.uuid) 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 import messaging
from oslo_config import cfg from oslo_config import cfg
from oslo_db import exception as db_exception 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 boot_devices
from ironic.common import driver_factory from ironic.common import driver_factory
@ -32,7 +34,6 @@ from ironic.common import exception
from ironic.common import keystone from ironic.common import keystone
from ironic.common import states from ironic.common import states
from ironic.common import swift from ironic.common import swift
from ironic.common import utils as ironic_utils
from ironic.conductor import manager from ironic.conductor import manager
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic.conductor import utils as conductor_utils from ironic.conductor import utils as conductor_utils
@ -53,7 +54,7 @@ class _CommonMixIn(object):
@staticmethod @staticmethod
def _create_node(**kwargs): def _create_node(**kwargs):
attrs = {'id': 1, attrs = {'id': 1,
'uuid': ironic_utils.generate_uuid(), 'uuid': uuidutils.generate_uuid(),
'power_state': states.POWER_OFF, 'power_state': states.POWER_OFF,
'maintenance': False, 'maintenance': False,
'reservation': None} 'reservation': None}
@ -127,7 +128,7 @@ class _CommonMixIn(object):
# NOTE(comstud): Not ideal to throw this into # NOTE(comstud): Not ideal to throw this into
# a helper, however it's the cleanest way # a helper, however it's the cleanest way
# to verify we're dealing with the correct task/node. # 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) self.assertEqual(fa_self.node_id, task.node.id)
else: else:
self.assertEqual(fa_self.node_id, task.node.uuid) 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): def _test_do_node_tear_down_from_state(self, init_state, mock_tear_down):
mock_tear_down.return_value = states.DELETED mock_tear_down.return_value = states.DELETED
node = obj_utils.create_test_node(self.context, driver='fake', node = obj_utils.create_test_node(self.context, driver='fake',
uuid=ironic_utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
provision_state=init_state, provision_state=init_state,
target_provision_state=states.NOSTATE) target_provision_state=states.NOSTATE)
@ -2371,7 +2372,7 @@ class ManagerSyncPowerStatesTestCase(_CommonMixIn, tests_db_base.DbTestCase):
mapped_map = {} mapped_map = {}
for i in range(1, 12): for i in range(1, 12):
attrs = {'id': i, attrs = {'id': i,
'uuid': ironic_utils.generate_uuid()} 'uuid': uuidutils.generate_uuid()}
if i == 3: if i == 3:
attrs['provision_state'] = states.DEPLOYWAIT attrs['provision_state'] = states.DEPLOYWAIT
attrs['target_provision_state'] = states.ACTIVE attrs['target_provision_state'] = states.ACTIVE

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

@ -20,12 +20,12 @@
import eventlet import eventlet
from eventlet import greenpool from eventlet import greenpool
import mock import mock
from oslo_utils import uuidutils
from ironic.common import driver_factory from ironic.common import driver_factory
from ironic.common import exception from ironic.common import exception
from ironic.common import fsm from ironic.common import fsm
from ironic.common import states from ironic.common import states
from ironic.common import utils
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic import objects from ironic import objects
from ironic.tests import base as tests_base from ironic.tests import base as tests_base
@ -89,7 +89,7 @@ class TaskManagerTestCase(tests_db_base.DbTestCase):
reserve_mock, release_mock, reserve_mock, release_mock,
node_get_mock): node_get_mock):
node2 = obj_utils.create_test_node(self.context, node2 = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake') driver='fake')
reserve_mock.return_value = self.node 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_base
from oslo_db.sqlalchemy import test_migrations from oslo_db.sqlalchemy import test_migrations
from oslo_db.sqlalchemy import utils as db_utils from oslo_db.sqlalchemy import utils as db_utils
from oslo_utils import uuidutils
import sqlalchemy import sqlalchemy
import sqlalchemy.exc import sqlalchemy.exc
from ironic.common.i18n import _LE from ironic.common.i18n import _LE
from ironic.common import utils
from ironic.db.sqlalchemy import migration from ironic.db.sqlalchemy import migration
from ironic.db.sqlalchemy import models from ironic.db.sqlalchemy import models
from ironic.openstack.common import log as logging from ironic.openstack.common import log as logging
@ -310,10 +310,10 @@ class MigrationCheckersMixin(object):
nodes = db_utils.get_table(engine, 'nodes') nodes = db_utils.get_table(engine, 'nodes')
instance_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' instance_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
data = {'driver': 'fake', data = {'driver': 'fake',
'uuid': utils.generate_uuid(), 'uuid': uuidutils.generate_uuid(),
'instance_uuid': instance_uuid} 'instance_uuid': instance_uuid}
nodes.insert().values(data).execute() nodes.insert().values(data).execute()
data['uuid'] = utils.generate_uuid() data['uuid'] = uuidutils.generate_uuid()
# TODO(viktors): Remove check on sqlalchemy.exc.IntegrityError, when # TODO(viktors): Remove check on sqlalchemy.exc.IntegrityError, when
# Ironic will use oslo_db 0.4.0 or higher. # Ironic will use oslo_db 0.4.0 or higher.
# See bug #1214341 for details. # See bug #1214341 for details.
@ -332,13 +332,13 @@ class MigrationCheckersMixin(object):
# add some nodes in various states so we can assert that "None" # add some nodes in various states so we can assert that "None"
# was replaced by "available", and nothing else changed. # was replaced by "available", and nothing else changed.
nodes = db_utils.get_table(engine, 'nodes') nodes = db_utils.get_table(engine, 'nodes')
data = [{'uuid': utils.generate_uuid(), data = [{'uuid': uuidutils.generate_uuid(),
'provision_state': 'fake state'}, 'provision_state': 'fake state'},
{'uuid': utils.generate_uuid(), {'uuid': uuidutils.generate_uuid(),
'provision_state': 'active'}, 'provision_state': 'active'},
{'uuid': utils.generate_uuid(), {'uuid': uuidutils.generate_uuid(),
'provision_state': 'deleting'}, 'provision_state': 'deleting'},
{'uuid': utils.generate_uuid(), {'uuid': uuidutils.generate_uuid(),
'provision_state': None}] 'provision_state': None}]
nodes.insert().values(data).execute() nodes.insert().values(data).execute()
return data return data

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

@ -13,8 +13,8 @@
"""Tests for custom SQLAlchemy types via Ironic DB.""" """Tests for custom SQLAlchemy types via Ironic DB."""
from oslo_db import exception as db_exc 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 import ironic.db.sqlalchemy.api as sa_api
from ironic.db.sqlalchemy import models from ironic.db.sqlalchemy import models
from ironic.tests.db import base from ironic.tests.db import base
@ -27,14 +27,14 @@ class SqlAlchemyCustomTypesTestCase(base.DbTestCase):
def test_JSONEncodedDict_default_value(self): def test_JSONEncodedDict_default_value(self):
# Create chassis w/o extra specified. # Create chassis w/o extra specified.
ch1_id = ironic_utils.generate_uuid() ch1_id = uuidutils.generate_uuid()
self.dbapi.create_chassis({'uuid': ch1_id}) self.dbapi.create_chassis({'uuid': ch1_id})
# Get chassis manually to test SA types in isolation from UOM. # Get chassis manually to test SA types in isolation from UOM.
ch1 = sa_api.model_query(models.Chassis).filter_by(uuid=ch1_id).one() ch1 = sa_api.model_query(models.Chassis).filter_by(uuid=ch1_id).one()
self.assertEqual({}, ch1.extra) self.assertEqual({}, ch1.extra)
# Create chassis with extra specified. # Create chassis with extra specified.
ch2_id = ironic_utils.generate_uuid() ch2_id = uuidutils.generate_uuid()
extra = {'foo1': 'test', 'foo2': 'other extra'} extra = {'foo1': 'test', 'foo2': 'other extra'}
self.dbapi.create_chassis({'uuid': ch2_id, 'extra': extra}) self.dbapi.create_chassis({'uuid': ch2_id, 'extra': extra})
# Get chassis manually to test SA types in isolation from UOM. # 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""" """Tests for manipulating Chassis via the DB API"""
from oslo_utils import uuidutils
import six import six
from ironic.common import exception from ironic.common import exception
from ironic.common import utils as ironic_utils
from ironic.tests.db import base from ironic.tests.db import base
from ironic.tests.db import utils from ironic.tests.db import utils
@ -33,7 +33,7 @@ class DbChassisTestCase(base.DbTestCase):
def test_get_chassis_list(self): def test_get_chassis_list(self):
uuids = [] uuids = []
for i in range(1, 6): 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) self.dbapi.create_chassis(n)
uuids.append(six.text_type(n['uuid'])) uuids.append(six.text_type(n['uuid']))
res = self.dbapi.get_chassis_list() res = self.dbapi.get_chassis_list()
@ -91,7 +91,7 @@ class DbChassisTestCase(base.DbTestCase):
self.dbapi.destroy_chassis, ch['id']) self.dbapi.destroy_chassis, ch['id'])
def test_create_chassis_already_exists(self): 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._create_test_chassis(id=1, uuid=uuid)
self.assertRaises(exception.ChassisAlreadyExists, self.assertRaises(exception.ChassisAlreadyExists,
self._create_test_chassis, self._create_test_chassis,

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

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

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

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

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

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

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

@ -25,6 +25,7 @@ import fixtures
import mock import mock
from oslo_concurrency import processutils from oslo_concurrency import processutils
from oslo_config import cfg from oslo_config import cfg
from oslo_utils import uuidutils
import requests import requests
from ironic.common import disk_partitioner 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): def test_get_single_nic_with_vif_port_id(self):
obj_utils.create_test_port(self.context, node_id=self.node.id, 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') extra={'vif_port_id': 'test-vif-A'}, driver='iscsi_ilo')
with task_manager.acquire(self.context, self.node.uuid, with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task: 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 import mock
from oslo_config import cfg from oslo_config import cfg
from oslo_utils import uuidutils
from pyghmi import exceptions as pyghmi_exception from pyghmi import exceptions as pyghmi_exception
from ironic.common import boot_devices from ironic.common import boot_devices
from ironic.common import driver_factory from ironic.common import driver_factory
from ironic.common import exception from ironic.common import exception
from ironic.common import states from ironic.common import states
from ironic.common import utils
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic.drivers.modules import console_utils from ironic.drivers.modules import console_utils
from ironic.drivers.modules import ipminative from ironic.drivers.modules import ipminative
@ -388,7 +388,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
def test_management_interface_validate_fail(self): def test_management_interface_validate_fail(self):
# Missing IPMI driver_info information # Missing IPMI driver_info information
node = obj_utils.create_test_node(self.context, node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
driver='fake_ipminative') driver='fake_ipminative')
with task_manager.acquire(self.context, node.uuid) as task: with task_manager.acquire(self.context, node.uuid) as task:
self.assertRaises(exception.MissingParameterValue, self.assertRaises(exception.MissingParameterValue,

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

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

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

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

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

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

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

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

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

@ -14,10 +14,10 @@
# under the License. # under the License.
import mock import mock
from oslo_utils import uuidutils
from testtools.matchers import HasLength from testtools.matchers import HasLength
from ironic.common import exception from ironic.common import exception
from ironic.common import utils as ironic_utils
from ironic import objects from ironic import objects
from ironic.tests.db import base from ironic.tests.db import base
from ironic.tests.db import utils from ironic.tests.db import utils
@ -74,7 +74,7 @@ class TestChassisObject(base.DbTestCase):
def test_refresh(self): def test_refresh(self):
uuid = self.fake_chassis['uuid'] uuid = self.fake_chassis['uuid']
new_uuid = ironic_utils.generate_uuid() new_uuid = uuidutils.generate_uuid()
returns = [dict(self.fake_chassis, uuid=uuid), returns = [dict(self.fake_chassis, uuid=uuid),
dict(self.fake_chassis, uuid=new_uuid)] dict(self.fake_chassis, uuid=new_uuid)]
expected = [mock.call(uuid), mock.call(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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
from oslo_utils import uuidutils
from ironic.common import network from ironic.common import network
from ironic.common import utils
from ironic.conductor import task_manager from ironic.conductor import task_manager
from ironic.tests.conductor import utils as mgr_utils from ironic.tests.conductor import utils as mgr_utils
from ironic.tests.db import base as db_base 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): def test_get_node_vif_ids_one_port(self):
port1 = db_utils.create_test_port(node_id=self.node.id, port1 = db_utils.create_test_port(node_id=self.node.id,
address='aa:bb:cc', address='aa:bb:cc',
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'}, extra={'vif_port_id': 'test-vif-A'},
driver='fake') driver='fake')
expected = {port1.uuid: 'test-vif-A'} expected = {port1.uuid: 'test-vif-A'}
@ -49,12 +50,12 @@ class TestNetwork(db_base.DbTestCase):
def test_get_node_vif_ids_two_ports(self): def test_get_node_vif_ids_two_ports(self):
port1 = db_utils.create_test_port(node_id=self.node.id, port1 = db_utils.create_test_port(node_id=self.node.id,
address='aa:bb:cc', address='aa:bb:cc',
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'}, extra={'vif_port_id': 'test-vif-A'},
driver='fake') driver='fake')
port2 = db_utils.create_test_port(node_id=self.node.id, port2 = db_utils.create_test_port(node_id=self.node.id,
address='dd:ee:ff', address='dd:ee:ff',
uuid=utils.generate_uuid(), uuid=uuidutils.generate_uuid(),
extra={'vif_port_id': 'test-vif-B'}, extra={'vif_port_id': 'test-vif-B'},
driver='fake') driver='fake')
expected = {port1.uuid: 'test-vif-A', port2.uuid: 'test-vif-B'} 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 os.path
import shutil import shutil
import tempfile import tempfile
import uuid
import mock import mock
import netaddr import netaddr
@ -443,46 +442,6 @@ class MkfsTestCase(base.TestCase):
'ext4', '/my/block/dev', 'ext4-vol') '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): class TempFilesTestCase(base.TestCase):
def test_tempdir(self): def test_tempdir(self):