def test_get_all_by_node_uuid_and_name(self, mock_get_rpc_node):
# GET /v1/ports specifying node and uuid - should only use node_uuid
mock_get_rpc_node.return_value = self.node
obj_utils.create_test_port(self.context, node_id=self.node.id)
self.get_json('/ports/detail?node_uuid=%s&node=%s' %
(self.node.uuid, 'node-name'))
mock_get_rpc_node.assert_called_once_with(self.node.uuid)
def test_get_all_by_node_uuid_and_name(self, mock_get_rpc_node):
# GET /v1/ports specifying node and uuid - should only use node_uuid
mock_get_rpc_node.return_value = self.node
obj_utils.create_test_port(self.context, node_id=self.node.id)
self.get_json('/ports/detail?node_uuid=%s&node=%s' %
(self.node.uuid, 'node-name'))
mock_get_rpc_node.assert_called_once_with(self.node.uuid)
def test_detail_by_node_name_not_supported(self, mock_get_rpc_node):
# GET /v1/ports/detail specifying node_name - name not supported
mock_get_rpc_node.side_effect = exception.InvalidUuidOrName(name=self.node.uuid)
obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json("/ports/detail?node=%s" % "test-node", expect_errors=True)
self.assertEqual(0, mock_get_rpc_node.call_count)
self.assertEqual(http_client.NOT_ACCEPTABLE, data.status_int)
def test_port_by_address_invalid_address_format(self):
obj_utils.create_test_port(self.context, node_id=self.node.id)
invalid_address = "invalid-mac-format"
response = self.get_json("/ports?address=%s" % invalid_address, expect_errors=True)
self.assertEqual(400, response.status_int)
self.assertEqual("application/json", response.content_type)
self.assertIn(invalid_address, response.json["error_message"])
def test_port_by_address_invalid_address_format(self):
obj_utils.create_test_port(self.context)
invalid_address = 'invalid-mac-format'
response = self.get_json('/ports?address=%s' % invalid_address,
expect_errors=True)
self.assertEqual(400, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertIn(invalid_address, response.json['error_message'])
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=utils.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:
address = ilo_deploy._get_single_nic_with_vif_port_id(task)
self.assertEqual('aa:bb:cc', address)
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=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:
address = utils.get_single_nic_with_vif_port_id(task)
self.assertEqual('aa:bb:cc', address)
def test_port_by_address_invalid_address_format(self):
obj_utils.create_test_port(self.context)
invalid_address = 'invalid-mac-format'
response = self.get_json('/ports?address=%s' % invalid_address,
expect_errors=True)
self.assertEqual(400, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertIn(invalid_address, response.json['error_message'])
def test_detail_by_node_name_not_supported(self, mock_get_rpc_node):
# GET /v1/ports/detail specifying node_name - name not supported
mock_get_rpc_node.side_effect = (exception.InvalidUuidOrName(
name=self.node.uuid))
obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json('/ports/detail?node=%s' % 'test-node',
expect_errors=True)
self.assertEqual(0, mock_get_rpc_node.call_count)
self.assertEqual(http_client.NOT_ACCEPTABLE, data.status_int)
def test_clean_up_pxe_config(self, unlink_mock, rmtree_mock):
address = "aa:aa:aa:aa:aa:aa"
object_utils.create_test_port(self.context, node_id=self.node.id, address=address)
with task_manager.acquire(self.context, self.node.uuid) as task:
pxe_utils.clean_up_pxe_config(task)
unlink_mock.assert_called_once_with("/tftpboot/pxelinux.cfg/01-%s" % address.replace(":", "-"))
rmtree_mock.assert_called_once_with(os.path.join(CONF.pxe.tftp_root, self.node.uuid))
def test_get_all_by_node_name_not_supported(self, mock_get_rpc_node):
# GET /v1/ports specifying node_name - name not supported
mock_get_rpc_node.side_effect = exception.InvalidUuidOrName(name=self.node.uuid)
for i in range(3):
obj_utils.create_test_port(
self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address="52:54:00:cf:2d:3%s" % i
)
data = self.get_json("/ports?node=%s" % "test-node", expect_errors=True)
self.assertEqual(0, mock_get_rpc_node.call_count)
self.assertEqual(http_client.NOT_ACCEPTABLE, data.status_int)
def test_links(self):
uuid = utils.generate_uuid()
obj_utils.create_test_port(self.context, id=1, uuid=uuid)
data = self.get_json('/ports/%s' % uuid)
self.assertIn('links', data.keys())
self.assertEqual(2, len(data['links']))
self.assertIn(uuid, data['links'][0]['href'])
for l in data['links']:
bookmark = l['rel'] == 'bookmark'
self.assertTrue(self.validate_link(l['href'], bookmark=bookmark))
def test_links(self):
uuid = utils.generate_uuid()
obj_utils.create_test_port(self.context, uuid=uuid, node_id=self.node.id)
data = self.get_json("/ports/%s" % uuid)
self.assertIn("links", data.keys())
self.assertEqual(2, len(data["links"]))
self.assertIn(uuid, data["links"][0]["href"])
for l in data["links"]:
bookmark = l["rel"] == "bookmark"
self.assertTrue(self.validate_link(l["href"], bookmark=bookmark))
def test_links(self):
uuid = utils.generate_uuid()
obj_utils.create_test_port(self.context, id=1, uuid=uuid)
data = self.get_json('/ports/%s' % uuid)
self.assertIn('links', data.keys())
self.assertEqual(2, len(data['links']))
self.assertIn(uuid, data['links'][0]['href'])
for l in data['links']:
bookmark = l['rel'] == 'bookmark'
self.assertTrue(self.validate_link(l['href'], bookmark=bookmark))
def test_port_by_address(self):
address_template = "aa:bb:cc:dd:ee:f%d"
for id_ in range(3):
obj_utils.create_test_port(
self.context, node_id=self.node.id, uuid=utils.generate_uuid(), address=address_template % id_
)
target_address = address_template % 1
data = self.get_json("/ports?address=%s" % target_address)
self.assertThat(data["ports"], HasLength(1))
self.assertEqual(target_address, data["ports"][0]["address"])
def test_port_by_address(self):
address_template = "aa:bb:cc:dd:ee:f%d"
for id_ in range(3):
obj_utils.create_test_port(self.context,
id=id_,
uuid=utils.generate_uuid(),
address=address_template % id_)
target_address = address_template % 1
data = self.get_json('/ports?address=%s' % target_address)
self.assertThat(data['ports'], HasLength(1))
self.assertEqual(target_address, data['ports'][0]['address'])
def test_port_by_address(self):
address_template = "aa:bb:cc:dd:ee:f%d"
for id_ in range(3):
obj_utils.create_test_port(self.context,
id=id_,
uuid=utils.generate_uuid(),
address=address_template % id_)
target_address = address_template % 1
data = self.get_json('/ports?address=%s' % target_address)
self.assertThat(data['ports'], HasLength(1))
self.assertEqual(target_address, data['ports'][0]['address'])
def test_clean_up_pxe_config(self, unlink_mock, rmtree_mock):
address = "aa:aa:aa:aa:aa:aa"
object_utils.create_test_port(self.context, node_id=self.node.id,
address=address)
with task_manager.acquire(self.context, self.node.uuid) as task:
pxe_utils.clean_up_pxe_config(task)
unlink_mock.assert_called_once_with("/tftpboot/pxelinux.cfg/01-%s"
% address.replace(':', '-'))
rmtree_mock.assert_called_once_with(
os.path.join(CONF.pxe.tftp_root, self.node.uuid))
def test_get_collection_custom_fields(self):
fields = "uuid,extra"
for i in range(3):
obj_utils.create_test_port(
self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address="52:54:00:cf:2d:3%s" % i
)
data = self.get_json("/ports?fields=%s" % fields, headers={api_base.Version.string: str(api_v1.MAX_VER)})
self.assertEqual(3, len(data["ports"]))
for port in data["ports"]:
# We always append "links"
self.assertItemsEqual(["uuid", "extra", "links"], port)
def test_get_all_by_node_name_ok(self, mock_get_rpc_node):
# GET /v1/ports specifying node_name - success
mock_get_rpc_node.return_value = self.node
for i in range(5):
if i < 3:
node_id = self.node.id
else:
node_id = 100000 + i
obj_utils.create_test_port(
self.context, node_id=node_id, uuid=uuidutils.generate_uuid(), address="52:54:00:cf:2d:3%s" % i
)
data = self.get_json("/ports?node=%s" % "test-node", headers={api_base.Version.string: "1.5"})
self.assertEqual(3, len(data["ports"]))
def test_get_ip_addresses(self, get_ip_mock):
ip_address = '10.10.0.1'
address = "aa:aa:aa:aa:aa:aa"
expected = [ip_address]
object_utils.create_test_port(self.context, node_uuid=self.node.uuid,
address=address)
get_ip_mock.return_value = ip_address
with task_manager.acquire(self.context, self.node.uuid) as task:
api = dhcp_factory.DHCPFactory().provider
result = api.get_ip_addresses(task)
self.assertEqual(expected, result)
def test_get_all_by_node_name_not_supported(self, mock_get_rpc_node):
# GET /v1/ports specifying node_name - name not supported
mock_get_rpc_node.side_effect = (exception.InvalidUuidOrName(
name=self.node.uuid))
for i in range(3):
obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % i)
data = self.get_json("/ports?node=%s" % 'test-node',
expect_errors=True)
self.assertEqual(0, mock_get_rpc_node.call_count)
self.assertEqual(http_client.NOT_ACCEPTABLE, data.status_int)
def test_get_ip_addresses(self, get_ip_mock):
ip_address = '10.10.0.1'
address = "aa:aa:aa:aa:aa:aa"
expected = [ip_address]
object_utils.create_test_port(self.context,
node_id=self.node.id,
address=address)
get_ip_mock.return_value = ip_address
with task_manager.acquire(self.context, self.node.uuid) as task:
api = dhcp_factory.DHCPFactory().provider
result = api.get_ip_addresses(task)
self.assertEqual(expected, result)
def test__link_ip_address_pxe_configs(self, provider_mock, unlink_mock, create_link_mock):
ip_address = "10.10.0.1"
address = "aa:aa:aa:aa:aa:aa"
object_utils.create_test_port(self.context, node_id=self.node.id, address=address)
provider_mock.get_ip_addresses.return_value = [ip_address]
create_link_calls = [
mock.call(u"/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/config", u"/tftpboot/0A0A0001.conf")
]
with task_manager.acquire(self.context, self.node.uuid) as task:
pxe_utils._link_ip_address_pxe_configs(task)
unlink_mock.assert_called_once_with("/tftpboot/0A0A0001.conf")
create_link_mock.assert_has_calls(create_link_calls)
def test_clean_up_pxe_config_uefi(self, provider_mock, unlink_mock, rmtree_mock):
ip_address = "10.10.0.1"
address = "aa:aa:aa:aa:aa:aa"
properties = {"capabilities": "boot_mode:uefi"}
object_utils.create_test_port(self.context, node_id=self.node.id, address=address)
provider_mock.get_ip_addresses.return_value = [ip_address]
with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.properties = properties
pxe_utils.clean_up_pxe_config(task)
unlink_mock.assert_called_once_with("/tftpboot/0A0A0001.conf")
rmtree_mock.assert_called_once_with(os.path.join(CONF.pxe.tftp_root, self.node.uuid))
def test_get_all_by_node_name_ok(self, mock_get_rpc_node):
# GET /v1/ports specifying node_name - success
mock_get_rpc_node.return_value = self.node
for i in range(5):
if i < 3:
node_id = self.node.id
else:
node_id = 100000 + i
obj_utils.create_test_port(self.context,
node_id=node_id,
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % i)
data = self.get_json("/ports?node=%s" % 'test-node',
headers={api_base.Version.string: '1.5'})
self.assertEqual(3, len(data['ports']))
def test_get_node_mac_addresses(self):
ports = []
ports.append(
obj_utils.create_test_port(
self.context, address="aa:bb:cc", uuid="bb43dc0b-03f2-4d2e-ae87-c02d7f33cc53", node_id=self.node.id
)
)
ports.append(
obj_utils.create_test_port(
self.context, address="dd:ee:ff", uuid="4fc26c0b-03f2-4d2e-ae87-c02d7f33c234", node_id=self.node.id
)
)
with task_manager.acquire(self.context, self.node.uuid) as task:
node_macs = driver_utils.get_node_mac_addresses(task)
self.assertEqual(sorted([p.address for p in ports]), sorted(node_macs))
def setUp(self):
super(TestNeutron, self).setUp()
mgr_utils.mock_the_extension_manager(driver="fake")
self.config(cleaning_network_uuid="00000000-0000-0000-0000-000000000000", group="neutron")
self.config(enabled_drivers=["fake"])
self.config(dhcp_provider="neutron", group="dhcp")
self.config(url="test-url", url_timeout=30, retries=2, group="neutron")
self.config(
insecure=False,
certfile="test-file",
admin_user="******",
admin_tenant_name="test-admin-tenant",
admin_password="******",
auth_uri="test-auth-uri",
group="keystone_authtoken",
)
self.node = object_utils.create_test_node(self.context)
self.ports = [
object_utils.create_test_port(
self.context,
node_id=self.node.id,
id=2,
uuid="1be26c0b-03f2-4d2e-ae87-c02d7f33c782",
address="52:54:00:cf:2d:32",
)
]
# Very simple neutron port representation
self.neutron_port = {"id": "132f871f-eaec-4fed-9475-0d54465e0f00", "mac_address": "52:54:00:cf:2d:32"}
dhcp_factory.DHCPFactory._dhcp_provider = None
def setUp(self):
super(TestNeutron, self).setUp()
mgr_utils.mock_the_extension_manager(driver='fake')
self.config(
cleaning_network_uuid='00000000-0000-0000-0000-000000000000',
group='neutron')
self.config(enabled_drivers=['fake'])
self.config(dhcp_provider='neutron', group='dhcp')
self.config(url='test-url', url_timeout=30, retries=2, group='neutron')
self.config(insecure=False,
certfile='test-file',
admin_user='******',
admin_tenant_name='test-admin-tenant',
admin_password='******',
auth_uri='test-auth-uri',
group='keystone_authtoken')
self.node = object_utils.create_test_node(self.context)
self.ports = [
object_utils.create_test_port(
self.context,
node_id=self.node.id,
id=2,
uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c782',
address='52:54:00:cf:2d:32')
]
# Very simple neutron port representation
self.neutron_port = {
'id': '132f871f-eaec-4fed-9475-0d54465e0f00',
'mac_address': '52:54:00:cf:2d:32'
}
dhcp_factory.DHCPFactory._dhcp_provider = None
def test_detail_by_node_name_ok(self, mock_get_rpc_node):
# GET /v1/ports/detail specifying node_name - success
mock_get_rpc_node.return_value = self.node
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json("/ports/detail?node=%s" % "test-node", headers={api_base.Version.string: "1.5"})
self.assertEqual(port.uuid, data["ports"][0]["uuid"])
self.assertEqual(self.node.uuid, data["ports"][0]["node_uuid"])
def test_get_collection_custom_fields(self):
fields = 'uuid,extra'
for i in range(3):
obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % i)
data = self.get_json(
'/ports?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.MAX_VER)})
self.assertEqual(3, len(data['ports']))
for port in data['ports']:
# We always append "links"
self.assertItemsEqual(['uuid', 'extra', 'links'], port)
def setUp(self):
super(TestNeutron, self).setUp()
mgr_utils.mock_the_extension_manager(driver='fake')
self.config(
cleaning_network_uuid='00000000-0000-0000-0000-000000000000',
group='neutron')
self.config(enabled_drivers=['fake'])
self.config(dhcp_provider='neutron',
group='dhcp')
self.config(url='test-url',
url_timeout=30,
retries=2,
group='neutron')
self.config(insecure=False,
certfile='test-file',
admin_user='******',
admin_tenant_name='test-admin-tenant',
admin_password='******',
auth_uri='test-auth-uri',
group='keystone_authtoken')
self.node = object_utils.create_test_node(self.context)
self.ports = [
object_utils.create_test_port(
self.context, node_id=self.node.id, id=2,
uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c782',
address='52:54:00:cf:2d:32')]
# Very simple neutron port representation
self.neutron_port = {'id': '132f871f-eaec-4fed-9475-0d54465e0f00',
'mac_address': '52:54:00:cf:2d:32'}
dhcp_factory.DHCPFactory._dhcp_provider = None
def setUp(self):
super(WakeOnLanPrivateMethodTestCase, self).setUp()
mgr_utils.mock_the_extension_manager(driver='fake_wol')
self.driver = driver_factory.get_driver('fake_wol')
self.node = obj_utils.create_test_node(self.context, driver='fake_wol')
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
def setUp(self):
super(CleanUpFullFlowTestCase, self).setUp()
self.config(image_cache_size=0, group='pxe')
# Configure node
mgr_utils.mock_the_extension_manager(driver="fake_pxe")
instance_info = INST_INFO_DICT
instance_info['deploy_key'] = 'fake-56789'
self.node = obj_utils.create_test_node(self.context,
driver='fake_pxe',
instance_info=instance_info,
driver_info=DRV_INFO_DICT)
self.dbapi = dbapi.get_instance()
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
# Configure temporary directories
pxe_temp_dir = tempfile.mkdtemp()
self.config(tftp_root=pxe_temp_dir, group='pxe')
tftp_master_dir = os.path.join(CONF.pxe.tftp_root, 'tftp_master')
self.config(tftp_master_path=tftp_master_dir, group='pxe')
os.makedirs(tftp_master_dir)
instance_temp_dir = tempfile.mkdtemp()
self.config(images_path=instance_temp_dir, group='pxe')
instance_master_dir = os.path.join(CONF.pxe.images_path,
'instance_master')
self.config(instance_master_path=instance_master_dir, group='pxe')
os.makedirs(instance_master_dir)
self.pxe_config_dir = os.path.join(CONF.pxe.tftp_root, 'pxelinux.cfg')
os.makedirs(self.pxe_config_dir)
# Populate some file names
self.master_kernel_path = os.path.join(CONF.pxe.tftp_master_path,
'kernel')
self.master_instance_path = os.path.join(CONF.pxe.instance_master_path,
'image_uuid')
self.node_tftp_dir = os.path.join(CONF.pxe.tftp_root, self.node.uuid)
os.makedirs(self.node_tftp_dir)
self.kernel_path = os.path.join(self.node_tftp_dir, 'kernel')
self.node_image_dir = iscsi_deploy._get_image_dir_path(self.node.uuid)
os.makedirs(self.node_image_dir)
self.image_path = iscsi_deploy._get_image_file_path(self.node.uuid)
self.config_path = pxe_utils.get_pxe_config_file_path(self.node.uuid)
self.mac_path = pxe_utils._get_pxe_mac_path(self.port.address)
self.token_path = pxe._get_token_file_path(self.node.uuid)
# Create files
self.files = [
self.config_path, self.master_kernel_path,
self.master_instance_path, self.token_path
]
for fname in self.files:
# NOTE(dtantsur): files with 0 size won't be cleaned up
with open(fname, 'w') as fp:
fp.write('test')
os.link(self.config_path, self.mac_path)
os.link(self.master_kernel_path, self.kernel_path)
os.link(self.master_instance_path, self.image_path)
def test_get_custom_fields_invalid_api_version(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
fields = 'uuid,extra'
response = self.get_json(
'/ports/%s?fields=%s' % (port.uuid, fields),
headers={api_base.Version.string: str(api_v1.MIN_VER)},
expect_errors=True)
self.assertEqual(406, response.status_int)
def test_detail_by_node_name_ok(self, mock_get_rpc_node):
# GET /v1/ports/detail specifying node_name - success
mock_get_rpc_node.return_value = self.node
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json('/ports/detail?node=%s' % 'test-node',
headers={api_base.Version.string: '1.5'})
self.assertEqual(port.uuid, data['ports'][0]['uuid'])
self.assertEqual(self.node.uuid, data['ports'][0]['node_uuid'])
def test_get_one_custom_fields(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
fields = 'address,extra'
data = self.get_json(
'/ports/%s?fields=%s' % (port.uuid, fields),
headers={api_base.Version.string: str(api_v1.MAX_VER)})
# We always append "links"
self.assertItemsEqual(['address', 'extra', 'links'], data)
def test_get_one(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json('/ports/%s' % port.uuid)
self.assertEqual(port.uuid, data['uuid'])
self.assertIn('extra', data)
self.assertIn('node_uuid', data)
# never expose the node_id
self.assertNotIn('node_id', data)
def test_detail_by_node_name_ok(self, mock_get_rpc_node):
# GET /v1/ports/detail specifying node_name - success
mock_get_rpc_node.return_value = self.node
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json('/ports/detail?node=%s' % 'test-node',
headers={api_base.Version.string: '1.5'})
self.assertEqual(port.uuid, data['ports'][0]['uuid'])
self.assertEqual(self.node.uuid, data['ports'][0]['node_uuid'])
def test_detail(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json('/ports/detail')
self.assertEqual(port.uuid, data['ports'][0]["uuid"])
self.assertIn('extra', data['ports'][0])
self.assertIn('node_uuid', data['ports'][0])
# never expose the node_id
self.assertNotIn('node_id', data['ports'][0])
def test_clean_up_pxe_config_uefi_instance_info(self,
provider_mock, unlink_mock,
rmtree_mock):
ip_address = '10.10.0.1'
address = "aa:aa:aa:aa:aa:aa"
object_utils.create_test_port(self.context, node_id=self.node.id,
address=address)
provider_mock.get_ip_addresses.return_value = [ip_address]
with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.instance_info['deploy_boot_mode'] = 'uefi'
pxe_utils.clean_up_pxe_config(task)
unlink_mock.assert_called_once_with('/tftpboot/0A0A0001.conf')
rmtree_mock.assert_called_once_with(
os.path.join(CONF.pxe.tftp_root, self.node.uuid))
def test_clean_up_pxe_config_uefi_instance_info(self, provider_mock,
unlink_mock, rmtree_mock):
ip_address = '10.10.0.1'
address = "aa:aa:aa:aa:aa:aa"
object_utils.create_test_port(self.context,
node_id=self.node.id,
address=address)
provider_mock.get_ip_addresses.return_value = [ip_address]
with task_manager.acquire(self.context, self.node.uuid) as task:
task.node.instance_info['deploy_boot_mode'] = 'uefi'
pxe_utils.clean_up_pxe_config(task)
unlink_mock.assert_called_once_with('/tftpboot/0A0A0001.conf')
rmtree_mock.assert_called_once_with(
os.path.join(CONF.pxe.tftp_root, self.node.uuid))
def test_get_one_custom_fields(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
fields = 'address,extra'
data = self.get_json(
'/ports/%s?fields=%s' % (port.uuid, fields),
headers={api_base.Version.string: str(api_v1.MAX_VER)})
# We always append "links"
self.assertItemsEqual(['address', 'extra', 'links'], data)
def test__link_ip_address_pxe_configs(self, provider_mock, unlink_mock,
create_link_mock):
ip_address = '10.10.0.1'
address = "aa:aa:aa:aa:aa:aa"
object_utils.create_test_port(self.context, node_id=self.node.id,
address=address)
provider_mock.get_ip_addresses.return_value = [ip_address]
create_link_calls = [
mock.call(u'/tftpboot/1be26c0b-03f2-4d2e-ae87-c02d7f33c123/config',
u'/tftpboot/0A0A0001.conf'),
]
with task_manager.acquire(self.context, self.node.uuid) as task:
pxe_utils._link_ip_address_pxe_configs(task)
unlink_mock.assert_called_once_with('/tftpboot/0A0A0001.conf')
create_link_mock.assert_has_calls(create_link_calls)
def test_get_custom_fields_invalid_api_version(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
fields = 'uuid,extra'
response = self.get_json(
'/ports/%s?fields=%s' % (port.uuid, fields),
headers={api_base.Version.string: str(api_v1.MIN_VER)},
expect_errors=True)
self.assertEqual(http_client.NOT_ACCEPTABLE, response.status_int)
def test_get_one(self):
port = obj_utils.create_test_port(self.context)
data = self.get_json('/ports/%s' % port.uuid)
self.assertEqual(port.uuid, data['uuid'])
self.assertIn('extra', data)
self.assertIn('node_uuid', data)
# never expose the node_id
self.assertNotIn('node_id', data)
def test_detail(self):
port = obj_utils.create_test_port(self.context)
data = self.get_json('/ports/detail')
self.assertEqual(port.uuid, data['ports'][0]["uuid"])
self.assertIn('extra', data['ports'][0])
self.assertIn('node_uuid', data['ports'][0])
# never expose the node_id
self.assertNotIn('node_id', data['ports'][0])
def test_detail(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json("/ports/detail")
self.assertEqual(port.uuid, data["ports"][0]["uuid"])
self.assertIn("extra", data["ports"][0])
self.assertIn("node_uuid", data["ports"][0])
# never expose the node_id
self.assertNotIn("node_id", data["ports"][0])
def setUp(self):
super(WakeOnLanPrivateMethodTestCase, self).setUp()
mgr_utils.mock_the_extension_manager(driver='fake_wol')
self.driver = driver_factory.get_driver('fake_wol')
self.node = obj_utils.create_test_node(self.context,
driver='fake_wol')
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
def test_get_node_mac_addresses(self):
ports = []
ports.append(
obj_utils.create_test_port(
self.context,
address='aa:bb:cc',
uuid='bb43dc0b-03f2-4d2e-ae87-c02d7f33cc53',
node_id=self.node.id))
ports.append(
obj_utils.create_test_port(
self.context,
address='dd:ee:ff',
uuid='4fc26c0b-03f2-4d2e-ae87-c02d7f33c234',
node_id=self.node.id))
with task_manager.acquire(self.context, self.node.uuid) as task:
node_macs = driver_utils.get_node_mac_addresses(task)
self.assertEqual(sorted([p.address for p in ports]), sorted(node_macs))
def test_get_one(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
data = self.get_json("/ports/%s" % port.uuid)
self.assertEqual(port.uuid, data["uuid"])
self.assertIn("extra", data)
self.assertIn("node_uuid", data)
# never expose the node_id
self.assertNotIn("node_id", data)
def setUp(self):
super(TestPatch, self).setUp()
self.node = obj_utils.create_test_node(context.get_admin_context())
self.port = obj_utils.create_test_port(self.context)
p = mock.patch.object(rpcapi.ConductorAPI, 'get_topic_for')
self.mock_gtf = p.start()
self.mock_gtf.return_value = 'test-topic'
self.addCleanup(p.stop)
def setUp(self):
super(TestPatch, self).setUp()
self.node = obj_utils.create_test_node(self.context)
self.port = obj_utils.create_test_port(self.context, node_id=self.node.id)
p = mock.patch.object(rpcapi.ConductorAPI, "get_topic_for")
self.mock_gtf = p.start()
self.mock_gtf.return_value = "test-topic"
self.addCleanup(p.stop)
def setUp(self):
super(SSHDriverTestCase, self).setUp()
mgr_utils.mock_the_extension_manager(driver="fake_ssh")
self.driver = driver_factory.get_driver("fake_ssh")
self.node = obj_utils.create_test_node(
self.context, driver='fake_ssh',
driver_info=db_utils.get_test_ssh_info())
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
self.sshclient = paramiko.SSHClient()
def setUp(self):
super(TestDelete, self).setUp()
self.node = obj_utils.create_test_node(self.context)
self.port = obj_utils.create_test_port(self.context,
node_id=self.node.id)
gtf = mock.patch.object(rpcapi.ConductorAPI, 'get_topic_for')
self.mock_gtf = gtf.start()
self.mock_gtf.return_value = 'test-topic'
self.addCleanup(gtf.stop)
def test_get_custom_fields_invalid_fields(self):
port = obj_utils.create_test_port(self.context, node_id=self.node.id)
fields = 'uuid,spongebob'
response = self.get_json(
'/ports/%s?fields=%s' % (port.uuid, fields),
headers={api_base.Version.string: str(api_v1.MAX_VER)},
expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertIn('spongebob', response.json['error_message'])
def test_sort_key(self):
ports = []
for id_ in range(3):
port = obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=uuidutils.generate_uuid(),
address='52:54:00:cf:2d:3%s' %
id_)
ports.append(port.uuid)
data = self.get_json('/ports?sort_key=uuid')
uuids = [n['uuid'] for n in data['ports']]
self.assertEqual(sorted(ports), uuids)
def test_many(self):
ports = []
for id_ in range(5):
port = obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=utils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid)
data = self.get_json('/ports')
self.assertEqual(len(ports), len(data['ports']))
uuids = [n['uuid'] for n in data['ports']]
self.assertEqual(ports.sort(), uuids.sort())
def test_collection_links(self):
ports = []
for id_ in range(5):
port = obj_utils.create_test_port(self.context,
node_id=self.node.id,
uuid=utils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id_)
ports.append(port.uuid)
data = self.get_json('/ports/?limit=3')
self.assertEqual(3, len(data['ports']))
next_marker = data['ports'][-1]['uuid']
self.assertIn(next_marker, data['next'])
def test_send_magic_packets(self, mock_socket):
fake_socket = mock.Mock(spec=socket, spec_set=True)
mock_socket.return_value = fake_socket()
obj_utils.create_test_port(self.context,
uuid=uuidutils.generate_uuid(),
address='aa:bb:cc:dd:ee:ff',
node_id=self.node.id)
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
wol._send_magic_packets(task, '255.255.255.255', 9)
expected_calls = [
mock.call(),
mock.call().setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,
1),
mock.call().sendto(mock.ANY, ('255.255.255.255', 9)),
mock.call().sendto(mock.ANY, ('255.255.255.255', 9)),
mock.call().close()
]
fake_socket.assert_has_calls(expected_calls)
self.assertEqual(1, mock_socket.call_count)
