def test_check_version_too_high(self):
self.version.major = v1_api.BASE_VERSION
self.version.minor = v1_api.max_version().minor + 1
e = self.assertRaises(
webob_exc.HTTPNotAcceptable,
v1_api.Controller()._check_version,
self.version, {'fake-headers': v1_api.max_version().minor})
self.assertEqual(v1_api.max_version().minor, e.headers['fake-headers'])
def test_detail_query_false(self):
obj_utils.create_test_chassis(self.context)
data1 = self.get_json(
'/chassis',
headers={api_base.Version.string: str(api_v1.max_version())})
data2 = self.get_json(
'/chassis?detail=False',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(data1['chassis'], data2['chassis'])
def _test_links(self, public_url=None):
cfg.CONF.set_override('public_endpoint', public_url, 'api')
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
headers = {api_base.Version.string: str(api_v1.max_version())}
data = self.get_json('/conductors/rocky.rocks', headers=headers)
self.assertIn('links', data)
self.assertEqual(2, len(data['links']))
self.assertIn('rocky.rocks', data['links'][0]['href'])
for link in data['links']:
bookmark = link['rel'] == 'bookmark'
self.assertTrue(
self.validate_link(link['href'],
bookmark=bookmark,
headers=headers))
if public_url is not None:
expected = [{
'href': '%s/v1/conductors/rocky.rocks' % public_url,
'rel': 'self'
}, {
'href': '%s/conductors/rocky.rocks' % public_url,
'rel': 'bookmark'
}]
for i in expected:
self.assertIn(i, data['links'])
def test_get_one_custom_fields(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
fields = 'hostname,alive'
data = self.get_json(
'/conductors/rocky.rocks?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertItemsEqual(['hostname', 'alive', 'links'], data)
def test_restrict_lookup(self):
response = self.get_json(
'/lookup?addresses=%s&node_uuid=%s' %
(','.join(self.addresses), self.node2.uuid),
headers={api_base.Version.string: str(api_v1.max_version())},
expect_errors=True)
self.assertEqual(http_client.NOT_FOUND, response.status_int)
def test_detail_using_query_and_fields(self):
obj_utils.create_test_chassis(self.context)
response = self.get_json(
'/chassis?detail=True&fields=description',
headers={api_base.Version.string: str(api_v1.max_version())},
expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
def test_detail_using_query_false_and_fields(self):
obj_utils.create_test_chassis(self.context)
data = self.get_json(
'/chassis?detail=False&fields=description',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertIn('description', data['chassis'][0])
self.assertNotIn('uuid', data['chassis'][0])
def test_detail_using_query_false_and_fields(self):
obj_utils.create_test_chassis(self.context)
data = self.get_json(
'/chassis?detail=False&fields=description',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertIn('description', data['chassis'][0])
self.assertNotIn('uuid', data['chassis'][0])
def test_detail_using_query_and_fields(self):
obj_utils.create_test_chassis(self.context)
response = self.get_json(
'/chassis?detail=True&fields=description',
headers={api_base.Version.string: str(api_v1.max_version())},
expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
def test_get_one_custom_fields(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
fields = 'hostname,alive'
data = self.get_json(
'/conductors/rocky.rocks?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertItemsEqual(['hostname', 'alive', 'links'], data)
def test_node_not_found(self):
response = self.post_json(
'/heartbeat/%s' % uuidutils.generate_uuid(),
{'callback_url': 'url'},
headers={api_base.Version.string: str(api_v1.max_version())},
expect_errors=True)
self.assertEqual(http_client.NOT_FOUND, response.status_int)
def test_detail_query(self):
chassis = obj_utils.create_test_chassis(self.context)
data = self.get_json(
'/chassis?detail=True',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(chassis.uuid, data['chassis'][0]["uuid"])
self.assertIn('extra', data['chassis'][0])
self.assertIn('nodes', data['chassis'][0])
def test_heartbeat_rejects_different_callback_url(self, mock_heartbeat):
node = obj_utils.create_test_node(
self.context, driver_internal_info={'agent_url': 'url'})
response = self.post_json(
'/heartbeat/%s' % node.uuid, {'callback_url': 'url2'},
headers={api_base.Version.string: str(api_v1.max_version())},
expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
def test_get_one_custom_fields(self):
chassis = obj_utils.create_test_chassis(self.context)
fields = 'extra,description'
data = self.get_json(
'/chassis/%s?fields=%s' % (chassis.uuid, fields),
headers={api_base.Version.string: str(api_v1.max_version())})
# We always append "links"
self.assertItemsEqual(['description', 'extra', 'links'], data)
def test_detail_using_query_false_and_fields(self):
obj_utils.create_test_deploy_template(self.context)
data = self.get_json(
'/deploy_templates?detail=False&fields=steps',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertIn('steps', data['deploy_templates'][0])
self.assertNotIn('uuid', data['deploy_templates'][0])
self.assertNotIn('extra', data['deploy_templates'][0])
def test_detail_query(self):
chassis = obj_utils.create_test_chassis(self.context)
data = self.get_json(
'/chassis?detail=True',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(chassis.uuid, data['chassis'][0]["uuid"])
self.assertIn('extra', data['chassis'][0])
self.assertIn('nodes', data['chassis'][0])
def test_get_one_custom_fields(self):
chassis = obj_utils.create_test_chassis(self.context)
fields = 'extra,description'
data = self.get_json(
'/chassis/%s?fields=%s' % (chassis.uuid, fields),
headers={api_base.Version.string: str(api_v1.max_version())})
# We always append "links"
self.assertItemsEqual(['description', 'extra', 'links'], data)
def test_found_by_only_uuid(self):
data = self.get_json(
'/lookup?node_uuid=%s' % self.node.uuid,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(self.node.uuid, data['node']['uuid'])
self.assertEqual(
set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node']))
self._check_config(data)
def test_get_volume(self):
headers = {api_base.Version.string: str(api_v1.max_version())}
data = self.get_json('/volume/', headers=headers)
for key in ['links', 'connectors', 'targets']:
self._test_links(data, key, headers)
self.assertIn('/volume/connectors', data['connectors'][0]['href'])
self.assertIn('/volume/connectors', data['connectors'][1]['href'])
self.assertIn('/volume/targets', data['targets'][0]['href'])
self.assertIn('/volume/targets', data['targets'][1]['href'])
def test_get_custom_fields_invalid_fields(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
fields = 'hostname,spongebob'
response = self.get_json(
'/conductors/rocky.rocks?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())},
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_found_by_uuid(self):
self._set_secret_mock(self.node, 'this_thing_on?')
data = self.get_json(
'/lookup?addresses=%s&node_uuid=%s' %
(','.join(self.addresses), self.node.uuid),
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(self.node.uuid, data['node']['uuid'])
self.assertEqual(
set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node']))
self._check_config(data)
def test_sort_key_invalid(self):
invalid_keys_list = ['alive', 'drivers']
headers = {api_base.Version.string: str(api_v1.max_version())}
for invalid_key in invalid_keys_list:
response = self.get_json('/conductors?sort_key=%s' % invalid_key,
headers=headers,
expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertIn(invalid_key, response.json['error_message'])
def test_get_custom_fields_invalid_fields(self):
chassis = obj_utils.create_test_chassis(self.context)
fields = 'uuid,spongebob'
response = self.get_json(
'/chassis/%s?fields=%s' % (chassis.uuid, fields),
headers={api_base.Version.string: str(api_v1.max_version())},
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_no_restrict_lookup(self):
CONF.set_override('restrict_lookup', False, 'api')
data = self.get_json(
'/lookup?addresses=%s&node_uuid=%s' %
(','.join(self.addresses), self.node2.uuid),
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(self.node2.uuid, data['node']['uuid'])
self.assertEqual(
set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node']))
self._check_config(data)
def test_get_custom_fields_invalid_fields(self):
chassis = obj_utils.create_test_chassis(self.context)
fields = 'uuid,spongebob'
response = self.get_json(
'/chassis/%s?fields=%s' % (chassis.uuid, fields),
headers={api_base.Version.string: str(api_v1.max_version())},
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_invalid(self):
invalid_keys_list = ['alive', 'drivers']
headers = {api_base.Version.string: str(api_v1.max_version())}
for invalid_key in invalid_keys_list:
response = self.get_json('/conductors?sort_key=%s' % invalid_key,
headers=headers,
expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertIn(invalid_key, response.json['error_message'])
def test_get_custom_fields_invalid_fields(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
fields = 'hostname,spongebob'
response = self.get_json(
'/conductors/rocky.rocks?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())},
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_fast_deploy_lookup(self):
CONF.set_override('fast_track', True, 'deploy')
for provision_state in [
states.ENROLL, states.MANAGEABLE, states.AVAILABLE
]:
self.node.provision_state = provision_state
data = self.get_json(
'/lookup?addresses=%s&node_uuid=%s' %
(','.join(self.addresses), self.node.uuid),
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(self.node.uuid, data['node']['uuid'])
def test_ok_by_name(self, mock_heartbeat):
node = obj_utils.create_test_node(self.context, name='test.1')
response = self.post_json(
'/heartbeat/%s' % node.name,
{'callback_url': 'url'},
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(http_client.ACCEPTED, response.status_int)
self.assertEqual(b'', response.body)
mock_heartbeat.assert_called_once_with(mock.ANY, mock.ANY,
node.uuid, 'url', None,
topic='test-topic')
def test_found_by_addresses(self):
obj_utils.create_test_port(self.context,
node_id=self.node.id,
address=self.addresses[1])
data = self.get_json(
'/lookup?addresses=%s' % ','.join(self.addresses),
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(self.node.uuid, data['node']['uuid'])
self.assertEqual(
set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node']))
self._check_config(data)
def test_get_collection_custom_fields(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
obj_utils.create_test_conductor(self.context, hostname='stein.rocks')
fields = 'hostname,alive'
data = self.get_json(
'/conductors?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(2, len(data['conductors']))
for c in data['conductors']:
self.assertItemsEqual(['hostname', 'alive', 'links'], c)
def test_get_collection_custom_fields(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
obj_utils.create_test_conductor(self.context, hostname='stein.rocks')
fields = 'hostname,alive'
data = self.get_json(
'/conductors?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(2, len(data['conductors']))
for c in data['conductors']:
self.assertItemsEqual(['hostname', 'alive', 'links'], c)
def test_get_one(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
data = self.get_json(
'/conductors/rocky.rocks',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertIn('hostname', data)
self.assertIn('drivers', data)
self.assertIn('conductor_group', data)
self.assertIn('alive', data)
self.assertIn('drivers', data)
self.assertEqual(data['hostname'], 'rocky.rocks')
self.assertTrue(data['alive'])
def test_sort_key(self):
conductors = []
for id in range(5):
hostname = uuidutils.generate_uuid()
conductor = obj_utils.create_test_conductor(self.context,
hostname=hostname)
conductors.append(conductor.hostname)
data = self.get_json(
'/conductors?sort_key=hostname',
headers={api_base.Version.string: str(api_v1.max_version())})
hosts = [n['hostname'] for n in data['conductors']]
self.assertEqual(sorted(conductors), hosts)
def test_get_one(self):
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
data = self.get_json(
'/conductors/rocky.rocks',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertIn('hostname', data)
self.assertIn('drivers', data)
self.assertIn('conductor_group', data)
self.assertIn('alive', data)
self.assertIn('drivers', data)
self.assertEqual(data['hostname'], 'rocky.rocks')
self.assertTrue(data['alive'])
def test_sort_key(self):
conductors = []
for id in range(5):
hostname = uuidutils.generate_uuid()
conductor = obj_utils.create_test_conductor(self.context,
hostname=hostname)
conductors.append(conductor.hostname)
data = self.get_json(
'/conductors?sort_key=hostname',
headers={api_base.Version.string: str(api_v1.max_version())})
hosts = [n['hostname'] for n in data['conductors']]
self.assertEqual(sorted(conductors), hosts)
def test_bad_invalid_agent_status(self, mock_heartbeat):
node = obj_utils.create_test_node(self.context)
response = self.post_json(
'/heartbeat/%s' % node.uuid, {
'callback_url': 'url',
'agent_token': 'meow',
'agent_status': 'invalid_state',
'agent_status_message': 'woof',
'agent_verify_ca': 'abcdef1'
},
headers={api_base.Version.string: str(api_v1.max_version())},
expect_errors=True)
self.assertEqual(http_client.BAD_REQUEST, response.status_int)
def test_get_volume(self):
headers = {api_base.Version.string: str(api_v1.max_version())}
data = self.get_json('/volume/', headers=headers)
for key in ['links', 'connectors', 'targets']:
self._test_links(data, key, headers)
self.assertIn('/volume/connectors',
data['connectors'][0]['href'])
self.assertIn('/volume/connectors',
data['connectors'][1]['href'])
self.assertIn('/volume/targets',
data['targets'][0]['href'])
self.assertIn('/volume/targets',
data['targets'][1]['href'])
def test_get_collection_custom_fields(self):
fields = 'uuid,extra'
for i in range(3):
obj_utils.create_test_chassis(
self.context, uuid=uuidutils.generate_uuid())
data = self.get_json(
'/chassis?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(3, len(data['chassis']))
for ch in data['chassis']:
# We always append "links"
self.assertItemsEqual(['uuid', 'extra', 'links'], ch)
def test_list(self):
obj_utils.create_test_conductor(self.context, hostname='why care')
obj_utils.create_test_conductor(self.context, hostname='why not')
data = self.get_json(
'/conductors',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(2, len(data['conductors']))
for c in data['conductors']:
self.assertIn('hostname', c)
self.assertIn('conductor_group', c)
self.assertIn('alive', c)
self.assertNotIn('drivers', c)
self.assertEqual(data['conductors'][0]['hostname'], 'why care')
self.assertEqual(data['conductors'][1]['hostname'], 'why not')
def test_collection_links(self):
conductors = []
for id in range(5):
hostname = uuidutils.generate_uuid()
conductor = obj_utils.create_test_conductor(self.context,
hostname=hostname)
conductors.append(conductor.hostname)
data = self.get_json(
'/conductors/?limit=3',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(3, len(data['conductors']))
next_marker = data['conductors'][-1]['hostname']
self.assertIn(next_marker, data['next'])
def test_list(self):
obj_utils.create_test_conductor(self.context, hostname='why care')
obj_utils.create_test_conductor(self.context, hostname='why not')
data = self.get_json(
'/conductors',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(2, len(data['conductors']))
for c in data['conductors']:
self.assertIn('hostname', c)
self.assertIn('conductor_group', c)
self.assertIn('alive', c)
self.assertNotIn('drivers', c)
self.assertEqual(data['conductors'][0]['hostname'], 'why care')
self.assertEqual(data['conductors'][1]['hostname'], 'why not')
def test_collection_links(self):
conductors = []
for id in range(5):
hostname = uuidutils.generate_uuid()
conductor = obj_utils.create_test_conductor(self.context,
hostname=hostname)
conductors.append(conductor.hostname)
data = self.get_json(
'/conductors/?limit=3',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(3, len(data['conductors']))
next_marker = data['conductors'][-1]['hostname']
self.assertIn(next_marker, data['next'])
def test_get_collection_custom_fields(self):
fields = 'uuid,extra'
for i in range(3):
obj_utils.create_test_chassis(
self.context, uuid=uuidutils.generate_uuid())
data = self.get_json(
'/chassis?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(3, len(data['chassis']))
for ch in data['chassis']:
# We always append "links"
self.assertItemsEqual(['uuid', 'extra', 'links'], ch)
def test_collection_links_custom_fields(self):
fields = 'extra,uuid'
cfg.CONF.set_override('max_limit', 3, 'api')
for i in range(5):
obj_utils.create_test_chassis(self.context,
uuid=uuidutils.generate_uuid())
data = self.get_json(
'/chassis?fields=%s' % fields,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(3, len(data['chassis']))
next_marker = data['chassis'][-1]['uuid']
self.assertIn(next_marker, data['next'])
self.assertIn('fields', data['next'])
def test_get_collection_pagination_no_uuid(self):
fields = 'extra'
limit = 2
chassis_list = []
for id_ in range(3):
chassis = obj_utils.create_test_chassis(
self.context, uuid=uuidutils.generate_uuid())
chassis_list.append(chassis)
data = self.get_json(
'/chassis?fields=%s&limit=%s' % (fields, limit),
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(limit, len(data['chassis']))
self.assertIn('marker=%s' % chassis_list[limit - 1].uuid, data['next'])
def test_ignore_malformed_address(self, mock_log):
obj_utils.create_test_port(self.context,
node_id=self.node.id,
address=self.addresses[1])
addresses = ('not-a-valid-address,80:00:02:48:fe:80:00:00:00:00:00:00'
':f4:52:14:03:00:54:06:c2,' + ','.join(self.addresses))
data = self.get_json(
'/lookup?addresses=%s' % addresses,
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(self.node.uuid, data['node']['uuid'])
self.assertEqual(
set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node']))
self._check_config(data)
self.assertTrue(mock_log.called)
def test_get_collection_pagination_no_uuid(self):
fields = 'extra'
limit = 2
chassis_list = []
for id_ in range(3):
chassis = obj_utils.create_test_chassis(
self.context,
uuid=uuidutils.generate_uuid())
chassis_list.append(chassis)
data = self.get_json(
'/chassis?fields=%s&limit=%s' % (fields, limit),
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual(limit, len(data['chassis']))
self.assertIn('marker=%s' % chassis_list[limit - 1].uuid, data['next'])
def test_get_one_conductor_offline(self, mock_utcnow):
self.config(heartbeat_timeout=10, group='conductor')
_time = datetime.datetime(2000, 1, 1, 0, 0)
mock_utcnow.return_value = _time
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
mock_utcnow.return_value = _time + datetime.timedelta(seconds=30)
data = self.get_json(
'/conductors/rocky.rocks',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertIn('hostname', data)
self.assertIn('drivers', data)
self.assertIn('conductor_group', data)
self.assertIn('alive', data)
self.assertIn('drivers', data)
self.assertEqual(data['hostname'], 'rocky.rocks')
self.assertFalse(data['alive'])
def _test_links(self, public_url=None):
cfg.CONF.set_override('public_endpoint', public_url, 'api')
obj_utils.create_test_conductor(self.context, hostname='rocky.rocks')
headers = {api_base.Version.string: str(api_v1.max_version())}
data = self.get_json(
'/conductors/rocky.rocks',
headers=headers)
self.assertIn('links', data)
self.assertEqual(2, len(data['links']))
self.assertIn('rocky.rocks', data['links'][0]['href'])
for l in data['links']:
bookmark = l['rel'] == 'bookmark'
self.assertTrue(self.validate_link(l['href'], bookmark=bookmark,
headers=headers))
if public_url is not None:
expected = [{'href': '%s/v1/conductors/rocky.rocks' % public_url,
'rel': 'self'},
{'href': '%s/conductors/rocky.rocks' % public_url,
'rel': 'bookmark'}]
for i in expected:
self.assertIn(i, data['links'])
def test_empty(self):
data = self.get_json(
'/conductors',
headers={api_base.Version.string: str(api_v1.max_version())})
self.assertEqual([], data['conductors'])
