def test_positive_get_routes():
"""Issue an HTTP GET response to both available routes.
:id: 9e40ea7f-71ea-4ced-94ba-cde03620c654
:expectedresults: The same response is returned.
:BZ: 1132817
:CaseImportance: Critical
"""
org = entities.Organization().create()
entities.SyncPlan(organization=org).create()
response1 = client.get(
f'{settings.server.get_url()}/katello/api/v2/sync_plans',
auth=settings.server.get_credentials(),
data={'organization_id': org.id},
verify=False,
)
response2 = client.get(
f'{settings.server.get_url()}/katello/api/v2/organizations/{org.id}/sync_plans',
auth=settings.server.get_credentials(),
verify=False,
)
for response in (response1, response2):
response.raise_for_status()
assert response1.json()['results'] == response2.json()['results']
def test_positive_get_routes(self):
"""Issue an HTTP GET response to both available routes.
@id: 9e40ea7f-71ea-4ced-94ba-cde03620c654
@Assert: The same response is returned.
Targets BZ 1132817.
"""
org = entities.Organization().create()
entities.SyncPlan(organization=org).create()
response1 = client.get(
'{0}/katello/api/v2/sync_plans'.format(settings.server.get_url()),
auth=settings.server.get_credentials(),
data={'organization_id': org.id},
verify=False,
)
response2 = client.get(
'{0}/katello/api/v2/organizations/{1}/sync_plans'.format(
settings.server.get_url(), org.id),
auth=settings.server.get_credentials(),
verify=False,
)
for response in (response1, response2):
response.raise_for_status()
self.assertEqual(
response1.json()['results'],
response2.json()['results'],
)
def test_get_routes(self):
"""@Test: Issue an HTTP GET response to both available routes.
@Assert: The same response is returned.
@Feature: SyncPlan
Targets BZ 1132817.
"""
org = entities.Organization().create()
entities.SyncPlan(organization=org).create()
response1 = client.get(
'{0}/katello/api/v2/sync_plans'.format(settings.server.get_url()),
auth=settings.server.get_credentials(),
data={'organization_id': org.id},
verify=False,
)
response2 = client.get(
'{0}/katello/api/v2/organizations/{1}/sync_plans'.format(
settings.server.get_url(),
org.id
),
auth=settings.server.get_credentials(),
verify=False,
)
for response in (response1, response2):
response.raise_for_status()
self.assertEqual(
response1.json()['results'],
response2.json()['results'],
)
def test_positive_get_routes(self):
"""Issue an HTTP GET response to both available routes.
:id: 9e40ea7f-71ea-4ced-94ba-cde03620c654
:expectedresults: The same response is returned.
Targets BZ 1132817.
:CaseImportance: Critical
"""
org = entities.Organization().create()
entities.SyncPlan(organization=org).create()
response1 = client.get(
'{0}/katello/api/v2/sync_plans'.format(settings.server.get_url()),
auth=settings.server.get_credentials(),
data={'organization_id': org.id},
verify=False,
)
response2 = client.get(
'{0}/katello/api/v2/organizations/{1}/sync_plans'.format(
settings.server.get_url(),
org.id
),
auth=settings.server.get_credentials(),
verify=False,
)
for response in (response1, response2):
response.raise_for_status()
self.assertEqual(
response1.json()['results'],
response2.json()['results'],
)
def test_positive_get_status_code(self):
"""GET an entity-dependent path.
:id: 89e4fafe-7780-4be4-acc1-90f7c02a8530
:expectedresults: HTTP 200 is returned with an ``application/json``
content-type
:CaseImportance: Critical
"""
exclude_list = (
entities.ActivationKey, # need organization_id or environment_id
entities.ContentView, # need organization_id
entities.GPGKey, # need organization_id
entities.HostCollection, # need organization_id
entities.LifecycleEnvironment, # need organization_id
entities.Product, # need organization_id
entities.Repository, # need organization_id
)
for entity_cls in set(valid_entities()) - set(exclude_list):
with self.subTest(entity_cls):
self.logger.info('test_get_status_code arg: %s', entity_cls)
skip_if_sam(self, entity_cls)
response = client.get(
entity_cls().path(),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
self.assertEqual(http_client.OK, response.status_code)
self.assertIn(
'application/json',
response.headers['content-type']
)
def test_positive_get_links(self):
"""GET ``api/v2`` and check the links returned.
:id: 7b2dd77a-a821-485b-94db-b583f93c9a89
:expectedresults: The paths returned are equal to ``API_PATHS``.
"""
# Did the server give us any paths at all?
response = client.get(
self.path,
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
# See below for an explanation of this transformation.
api_paths = response.json()['links']
for group, path_pairs in api_paths.items():
api_paths[group] = list(path_pairs.values())
if bz_bug_is_open(1166875):
# The server returns incorrect paths.
api_paths['docker_manifests'].append(
u'/katello/api/docker_manifests')
api_paths['docker_manifests'].remove(u'/katello/api/compare')
api_paths['docker_tags'].append(u'/katello/api/docker_tags')
api_paths['docker_tags'].remove(u'/katello/api/compare')
api_paths['errata'].append(u'/katello/api/errata')
api_paths['errata'].append(u'/katello/api/errata/compare')
api_paths['errata'].remove(u'/katello/api/compare')
self.assertEqual(frozenset(api_paths.keys()),
frozenset(API_PATHS.keys()))
for group in api_paths.keys():
self.assertItemsEqual(api_paths[group], API_PATHS[group], group)
def test_get_status_code(self):
"""@Test: GET an entity-dependent path.
@Feature: Test multiple API paths
@Assert: HTTP 200 is returned with an ``application/json`` content-type
"""
exclude_list = (
entities.ActivationKey, # need organization_id or environment_id
entities.ContentView, # need organization_id
entities.GPGKey, # need organization_id
entities.HostCollection, # need organization_id
entities.LifecycleEnvironment, # need organization_id
entities.Product, # need organization_id
entities.Repository, # need organization_id
entities.System, # need organization_id
)
for entity_cls in set(valid_entities()) - set(exclude_list):
with self.subTest(entity_cls):
logger.debug('test_get_status_code arg: %s', entity_cls)
skip_if_sam(self, entity_cls)
response = client.get(
entity_cls().path(),
auth=get_server_credentials(),
verify=False,
)
response.raise_for_status()
self.assertEqual(httplib.OK, response.status_code)
self.assertIn(
'application/json',
response.headers['content-type']
)
def test_positive_get_links(self):
"""GET ``api/v2`` and check the links returned.
:id: 7b2dd77a-a821-485b-94db-b583f93c9a89
:expectedresults: The paths returned are equal to ``API_PATHS``.
"""
# Did the server give us any paths at all?
response = client.get(
self.path,
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
# See below for an explanation of this transformation.
api_paths = response.json()['links']
for group, path_pairs in api_paths.items():
api_paths[group] = list(path_pairs.values())
self.assertEqual(
frozenset(api_paths.keys()),
frozenset(API_PATHS.keys())
)
for group in api_paths.keys():
self.assertItemsEqual(api_paths[group], API_PATHS[group], group)
def test_get_releases_status_code(self):
"""@Test: Get an activation key's releases. Check response format.
@Assert: HTTP 200 is returned with an ``application/json`` content-type
@Feature: ActivationKey
"""
try:
attrs = entities.ActivationKey().create()
except HTTPError as err:
self.fail(err)
path = entities.ActivationKey(id=attrs['id']).path(which='releases')
response = client.get(
path,
auth=get_server_credentials(),
verify=False,
)
status_code = httplib.OK
self.assertEqual(
status_code,
response.status_code,
status_code_error(path, status_code, response),
)
self.assertIn('application/json', response.headers['content-type'])
def test_ping(self):
"""@Test: Check if all services are running
@Feature: Smoke Test
@Assert: Overall and individual services status should be 'ok'.
"""
response = client.get(
entities.Ping().path(),
auth=get_server_credentials(),
verify=False,
)
response.raise_for_status()
self.assertEqual(response.json()['status'], u'ok') # overall status
# Check that all services are OK. ['services'] is in this format:
#
# {u'services': {
# u'candlepin': {u'duration_ms': u'40', u'status': u'ok'},
# u'candlepin_auth': {u'duration_ms': u'41', u'status': u'ok'},
# …
# }, u'status': u'ok'}
services = response.json()['services']
self.assertTrue(
all([service['status'] == u'ok' for service in services.values()]),
u"Not all services seem to be up and running!"
)
def test_positive_get_status_code(self):
"""GET an entity-dependent path.
:id: 89e4fafe-7780-4be4-acc1-90f7c02a8530
:expectedresults: HTTP 200 is returned with an ``application/json``
content-type
:CaseImportance: Critical
"""
exclude_list = (
entities.ActivationKey, # need organization_id or environment_id
entities.ContentView, # need organization_id
entities.GPGKey, # need organization_id
entities.HostCollection, # need organization_id
entities.LifecycleEnvironment, # need organization_id
entities.Product, # need organization_id
entities.Repository, # need organization_id
)
for entity_cls in set(valid_entities()) - set(exclude_list):
with self.subTest(entity_cls):
self.logger.info('test_get_status_code arg: %s', entity_cls)
skip_if_sam(self, entity_cls)
response = client.get(
entity_cls().path(),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
self.assertEqual(http_client.OK, response.status_code)
self.assertIn('application/json',
response.headers['content-type'])
def test_positive_build_pxe_default(self, tftpboot):
"""Call the "build_pxe_default" path.
:id: ca19d9da-1049-4b39-823b-933fc1a0cebd
:expectedresults: The response is a JSON payload, all templates are deployed to TFTP/HTTP
and are rendered correctly
:CaseLevel: Integration
:CaseImportance: Critical
:BZ: 1202564
"""
response = client.post(
entities.ProvisioningTemplate().path('build_pxe_default'),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
assert type(response.json()) == dict
for template in tftpboot.values():
if template['path'].startswith('http'):
r = client.get(template['path'], verify=False)
r.raise_for_status()
rendered = r.text
else:
rendered = ssh.command(f"cat {template['path']}").stdout[0]
assert (rendered == f"{settings.server.scheme}://"
f"{settings.server.hostname} {template['kind']}")
def test_negative_get_unauthorized(self):
"""GET an entity-dependent path without credentials.
:id: 49127c71-55a2-42d1-b418-59229e9bad00
:expectedresults: HTTP 401 is returned
:CaseImportance: Critical
"""
exclude_list = (
entities.ActivationKey, # need organization_id or environment_id
)
test_entities = self.get_entities_for_unauthorized(
valid_entities(), exclude_list)
for entity_cls in test_entities:
with self.subTest(entity_cls):
self.logger.info('test_get_unauthorized arg: %s', entity_cls)
skip_if_sam(self, entity_cls)
response = client.get(
entity_cls().path(),
auth=(),
verify=False
)
self.assertEqual(
http_client.UNAUTHORIZED, response.status_code)
def test_get_links(self):
"""@Test: GET ``api/v2`` and check the links returned.
@Feature: API
@Assert: The paths returned are equal to ``API_PATHS``.
"""
# Did the server give us any paths at all?
response = client.get(self.path, auth=helpers.get_server_credentials(), verify=False)
response.raise_for_status()
# See below for an explanation of this transformation.
api_paths = response.json()["links"]
for group, path_pairs in api_paths.items():
api_paths[group] = path_pairs.values()
if bz_bug_is_open(1166875):
# The server returns incorrect paths.
api_paths["docker_images"].append(u"/katello/api/docker_images")
api_paths["docker_images"].remove(u"/katello/api/compare")
api_paths["docker_tags"].append(u"/katello/api/docker_tags")
api_paths["docker_tags"].remove(u"/katello/api/compare")
api_paths["errata"].append(u"/katello/api/errata")
api_paths["errata"].append(u"/katello/api/errata/compare")
api_paths["errata"].remove(u"/katello/api/compare")
self.assertEqual(frozenset(api_paths.keys()), frozenset(API_PATHS.keys()))
for group in api_paths.keys():
self.assertItemsEqual(api_paths[group], API_PATHS[group], group)
def test_ping(self):
"""@Test: Check if all services are running
@Feature: Smoke Test
@Assert: Overall and individual services status should be 'ok'.
"""
response = client.get(
entities.Ping().path(),
auth=get_server_credentials(),
verify=False,
)
response.raise_for_status()
self.assertEqual(response.json()['status'], u'ok') # overall status
# Check that all services are OK. ['services'] is in this format:
#
# {u'services': {
# u'candlepin': {u'duration_ms': u'40', u'status': u'ok'},
# u'candlepin_auth': {u'duration_ms': u'41', u'status': u'ok'},
# …
# }, u'status': u'ok'}
services = response.json()['services']
self.assertTrue(
all([service['status'] == u'ok' for service in services.values()]),
u"Not all services seem to be up and running!"
)
def _search(self, entity, query, auth=None):
"""Performs a GET ``api/v2/<entity>`` and specify the ``search``
parameter.
:param robottelo.orm.Entity entity: A logical representation of a
Foreman entity.
:param string query: A ``search`` parameter.
:param tuple auth: A ``tuple`` containing the credentials to be used
for authentication when accessing the API. If ``None``,
credentials are automatically read from
:func:`robottelo.common.helpers.get_server_credentials`.
:return: A ``list`` of found entity dicts or an empty list if nothing
found
:rtype: list
"""
# Use the server credentials if None are provided
if auth is None:
auth = get_server_credentials()
path = entity().path()
response = client.get(
path,
auth=auth,
data={u'search': query},
verify=False,
)
response.raise_for_status()
return response.json()['results']
def test_positive_get_status_code(self):
"""GET an entity-dependent path.
@Feature: Test multiple API paths
@Assert: HTTP 200 is returned with an ``application/json`` content-type
"""
exclude_list = (
entities.ActivationKey, # need organization_id or environment_id
entities.ContentView, # need organization_id
entities.GPGKey, # need organization_id
entities.HostCollection, # need organization_id
entities.LifecycleEnvironment, # need organization_id
entities.Product, # need organization_id
entities.Repository, # need organization_id
entities.System, # need organization_id
)
for entity_cls in set(valid_entities()) - set(exclude_list):
with self.subTest(entity_cls):
logger.debug('test_get_status_code arg: %s', entity_cls)
skip_if_sam(self, entity_cls)
response = client.get(
entity_cls().path(),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
self.assertEqual(http_client.OK, response.status_code)
self.assertIn(
'application/json',
response.headers['content-type']
)
def test_positive_get_links(self):
"""GET ``api/v2`` and check the links returned.
:id: 7b2dd77a-a821-485b-94db-b583f93c9a89
:expectedresults: The paths returned are equal to ``API_PATHS``.
"""
# Did the server give us any paths at all?
response = client.get(
self.path,
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
# See below for an explanation of this transformation.
api_paths = response.json()['links']
for group, path_pairs in api_paths.items():
api_paths[group] = list(path_pairs.values())
self.assertEqual(
frozenset(api_paths.keys()),
frozenset(API_PATHS.keys())
)
for group in api_paths.keys():
self.assertItemsEqual(api_paths[group], API_PATHS[group], group)
def _search(self, entity, query, auth=None):
"""Performs a GET ``api/v2/<entity>`` and specify the ``search``
parameter.
:param entity: A ``nailgun.entity_mixins.Entity`` object.
:param string query: A ``search`` parameter.
:param tuple auth: A ``tuple`` containing the credentials to be used
for authentication when accessing the API. If ``None``,
credentials are automatically read from
:func:`robottelo.common.helpers.get_server_credentials`.
:return: A ``list`` of found entity dicts or an empty list if nothing
found
:rtype: list
"""
# Use the server credentials if None are provided
if auth is None:
auth = get_server_credentials()
path = entity().path()
response = client.get(
path,
auth=auth,
data={u'search': query},
verify=False,
)
response.raise_for_status()
return response.json()['results']
def get_organization(server_config, label):
"""Return the organization object with label ``label``.
This function is necessary because NailGun does not yet have a mixin
facilitating entity searches.
:param nailgun.config.ServerConfig server_config: This object defines which
server will be searched, what credentials will be used when searching
and so on.
:param label: A string label that will be used when searching. Every
organization should have a unique label.
:returns: An ``Organization`` object.
"""
response = client.get(
Organization(server_config).path(),
data={'search': 'label={}'.format(label)},
**server_config.get_client_kwargs()
)
response.raise_for_status()
decoded = response.json()
if decoded['subtotal'] != 1:
print(
'Expected to find one organization, but instead found {0}. Search '
'results: {1}'.format(decoded['subtotal'], decoded['results'])
)
exit(1)
return Organization(
server_config,
id=decoded['results'][0]['id']
).read()
def test_subscribe_system_to_cv(self):
"""@Test: Subscribe a system to a content view.
@Feature: ContentView
@Assert: It is possible to create a system and set its
'content_view_id' attribute.
"""
# organization
# ├── lifecycle environment
# └── content view
org = entities.Organization()
org.id = org.create()['id']
lifecycle_env = entities.LifecycleEnvironment(organization=org.id)
lifecycle_env.id = lifecycle_env.create()['id']
content_view = entities.ContentView(organization=org.id)
content_view.id = content_view.create()['id']
# Publish the content view.
response = content_view.publish()
humanized_errors = response['humanized']['errors']
_check_bz_1186432(humanized_errors)
self.assertEqual(response['result'], 'success', humanized_errors)
# Get the content view version's ID.
response = client.get(
entities.ContentViewVersion().path(),
auth=get_server_credentials(),
data={u'content_view_id': content_view.id},
verify=False,
)
response.raise_for_status()
results = response.json()['results']
self.assertEqual(len(results), 1)
cv_version = entities.ContentViewVersion(id=results[0]['id'])
# Promote the content view version.
response = cv_version.promote(environment_id=lifecycle_env.id)
humanized_errors = response['humanized']['errors']
_check_bz_1186432(humanized_errors)
self.assertEqual('success', response['result'], humanized_errors)
# Create a system that is subscribed to the published and promoted
# content view. Associating this system with the organization and
# environment created above is not particularly important, but doing so
# means a shorter test where fewer entities are created, as
# System.organization and System.environment are required attributes.
system_attrs = entities.System(
content_view=content_view.id,
environment=lifecycle_env.id,
organization=org.id,
).create()
# See BZ #1151240
self.assertEqual(system_attrs['content_view_id'], content_view.id)
self.assertEqual(system_attrs['environment']['id'], lifecycle_env.id)
self.assertEqual(system_attrs['organization_id'], org.id)
def test_subscribe_system_to_cv(self):
"""@Test: Subscribe a system to a content view.
@Feature: ContentView
@Assert: It is possible to create a system and set its
'content_view_id' attribute.
"""
# organization
# ├── lifecycle environment
# └── content view
org = entities.Organization()
org.id = org.create()['id']
lifecycle_env = entities.LifecycleEnvironment(organization=org.id)
lifecycle_env.id = lifecycle_env.create()['id']
content_view = entities.ContentView(organization=org.id)
content_view.id = content_view.create()['id']
# Publish the content view.
response = content_view.publish()
humanized_errors = response['humanized']['errors']
_check_bz_1186432(humanized_errors)
self.assertEqual(response['result'], 'success', humanized_errors)
# Get the content view version's ID.
response = client.get(
entities.ContentViewVersion().path(),
auth=get_server_credentials(),
data={u'content_view_id': content_view.id},
verify=False,
)
response.raise_for_status()
results = response.json()['results']
self.assertEqual(len(results), 1)
cv_version = entities.ContentViewVersion(id=results[0]['id'])
# Promote the content view version.
response = cv_version.promote(environment_id=lifecycle_env.id)
humanized_errors = response['humanized']['errors']
_check_bz_1186432(humanized_errors)
self.assertEqual('success', response['result'], humanized_errors)
# Create a system that is subscribed to the published and promoted
# content view. Associating this system with the organization and
# environment created above is not particularly important, but doing so
# means a shorter test where fewer entities are created, as
# System.organization and System.environment are required attributes.
system_attrs = entities.System(
content_view=content_view.id,
environment=lifecycle_env.id,
organization=org.id,
).create()
# See BZ #1151240
self.assertEqual(system_attrs['content_view_id'], content_view.id)
self.assertEqual(system_attrs['environment']['id'], lifecycle_env.id)
self.assertEqual(system_attrs['organization_id'], org.id)
def _poll_task(task_id, server_config, poll_rate=None, timeout=None):
"""Implement :meth:`nailgun.entities.ForemanTask.poll`.
See :meth:`nailgun.entities.ForemanTask.poll` for a full description of how
this method acts. Other methods may also call this method, such as
:meth:`nailgun.entity_mixins.EntityDeleteMixin.delete`.
Certain mixins benefit from being able to poll the server after performing
an operation. However, this module cannot use
:meth:`nailgun.entities.ForemanTask.poll`, as that would be a circular
import. Placing the implementation of
:meth:`nailgun.entities.ForemanTask.poll` here allows both that method and
the mixins in this module to use the same logic.
"""
if poll_rate is None:
poll_rate = TASK_POLL_RATE
if timeout is None:
timeout = TASK_TIMEOUT
# Implement the timeout.
def raise_task_timeout():
"""Raise a KeyboardInterrupt exception in the main thread."""
thread.interrupt_main()
timer = threading.Timer(timeout, raise_task_timeout)
# Poll until the task finishes. The timeout prevents an infinite loop.
try:
timer.start()
path = '{0}/foreman_tasks/api/tasks/{1}'.format(
server_config.url,
task_id
)
while True:
response = client.get(path, **server_config.get_client_kwargs())
response.raise_for_status()
task_info = response.json()
if task_info['state'] != 'running':
break
time.sleep(poll_rate)
except KeyboardInterrupt:
# raise_task_timeout will raise a KeyboardInterrupt when the timeout
# expires. Catch the exception and raise TaskTimedOutError
raise TaskTimedOutError('Timed out polling task {0}'.format(task_id))
finally:
timer.cancel()
# Check for task success or failure.
if task_info['result'] != 'success':
raise TaskFailedError(
'Task {0} completed with result {1}. Error message(s): {2}'.format(
task_id,
task_info['result'],
task_info['humanized']['errors']
)
)
return task_info
def read_raw(self):
"""Get information about the current entity.
Make an HTTP PUT call to ``self.path('self')``. Return the response.
:return: A ``requests.response`` object.
"""
return client.get(self.path('self'),
**self._server_config.get_client_kwargs())
def test_get_status_code(self):
"""@Test: GET ``api/v2`` and examine the response.
@Feature: API
@Assert: HTTP 200 is returned with an ``application/json`` content-type
"""
response = client.get(self.path, auth=helpers.get_server_credentials(), verify=False)
self.assertEqual(response.status_code, httplib.OK)
self.assertIn("application/json", response.headers["content-type"])
def _poll_task(task_id, server_config, poll_rate=None, timeout=None):
"""Implement :meth:`nailgun.entities.ForemanTask.poll`.
See :meth:`nailgun.entities.ForemanTask.poll` for a full description of how
this method acts. Other methods may also call this method, such as
:meth:`nailgun.entity_mixins.EntityDeleteMixin.delete`.
Certain mixins benefit from being able to poll the server after performing
an operation. However, this module cannot use
:meth:`nailgun.entities.ForemanTask.poll`, as that would be a circular
import. Placing the implementation of
:meth:`nailgun.entities.ForemanTask.poll` here allows both that method and
the mixins in this module to use the same logic.
"""
if poll_rate is None:
poll_rate = TASK_POLL_RATE
if timeout is None:
timeout = TASK_TIMEOUT
# Implement the timeout.
def raise_task_timeout(): # pragma: no cover
"""Raise a KeyboardInterrupt exception in the main thread."""
thread.interrupt_main()
timer = threading.Timer(timeout, raise_task_timeout)
# Poll until the task finishes. The timeout prevents an infinite loop.
path = '{0}/foreman_tasks/api/tasks/{1}'.format(server_config.url, task_id)
try:
timer.start()
while True:
response = client.get(path, **server_config.get_client_kwargs())
response.raise_for_status()
task_info = response.json()
if task_info['state'] in ('paused', 'stopped'):
break
time.sleep(poll_rate)
except KeyboardInterrupt: # pragma: no cover
# raise_task_timeout will raise a KeyboardInterrupt when the timeout
# expires. Catch the exception and raise TaskTimedOutError
raise TaskTimedOutError(
'Timed out polling task {0}. Task information: {1}'.format(
task_id, task_info))
finally:
timer.cancel()
# Check for task success or failure.
if task_info['result'] != 'success':
raise TaskFailedError(
'Task {0} did not succeed. Task information: {1}'.format(
task_id, task_info))
return task_info
def read_raw(self):
"""Get information about the current entity.
Make an HTTP PUT call to ``self.path('self')``. Return the response.
:return: A ``requests.response`` object.
"""
return client.get(
self.path('self'),
**self._server_config.get_client_kwargs()
)
def test_positive_get_status_code(self, api_url):
"""GET ``api/v2`` and examine the response.
:id: 9d9c1afd-9158-419e-9a6e-91e9888f0c04
:expectedresults: HTTP 200 is returned with an ``application/json``
content-type
"""
response = client.get(api_url, auth=get_credentials(), verify=False)
assert response.status_code == http.client.OK
assert 'application/json' in response.headers['content-type']
def test_get_unauthorized(self, entity_cls):
"""@Test: GET an entity-dependent path without credentials.
@Feature: Test multiple API paths
@Assert: HTTP 401 is returned
"""
logger.debug('test_get_unauthorized arg: %s', entity_cls)
skip_if_sam(self, entity_cls)
response = client.get(entity_cls().path(), auth=(), verify=False)
self.assertEqual(httplib.UNAUTHORIZED, response.status_code)
def test_get_with_no_args(self):
"""@Test: Issue an HTTP GET to the base content view filters path.
@Feature: ContentViewFilter
@Assert: An HTTP 400 or 422 response is received if a GET request is
issued with no arguments specified.
This test targets bugzilla bug #1102120.
"""
response = client.get(entities.AbstractContentViewFilter().path(), auth=get_server_credentials(), verify=False)
self.assertIn(response.status_code, (httplib.BAD_REQUEST, httplib.UNPROCESSABLE_ENTITY))
def _poll_task(task_id, poll_rate=None, timeout=None, auth=None):
"""Implement :meth:`robottelo.entities.ForemanTask.poll`.
See :meth:`robottelo.entities.ForemanTask.poll` for a full description of
how this method acts. Other methods may also call this method, such as
:meth:`robottelo.orm.EntityDeleteMixin.delete`.
This function has been placed in this module to keep the import tree sane.
This function could also be placed in :mod:`robottelo.api.utils`. However,
doing so precludes :mod:`robottelo.api.utils` from importing
:mod:`robottelo.entities`, which may be desirable in the future.
This function is private because only entity mixins should use this.
:class:`robottelo.entities.ForemanTask` is, for obvious reasons, an
exception.
"""
if poll_rate is None:
poll_rate = TASK_POLL_RATE
if timeout is None:
timeout = TASK_TIMEOUT
if auth is None:
auth = helpers.get_server_credentials()
# Implement the timeout.
def raise_task_timeout():
"""Raise a KeyboardInterrupt exception in the main thread."""
thread.interrupt_main()
timer = threading.Timer(timeout, raise_task_timeout)
# Poll until the task finishes. The timeout prevents an infinite loop.
try:
timer.start()
path = '{0}/foreman_tasks/api/tasks/{1}'.format(
helpers.get_server_url(), task_id)
while True:
response = client.get(path, auth=auth, verify=False)
response.raise_for_status()
task_info = response.json()
if task_info['state'] != 'running':
return task_info
time.sleep(poll_rate)
except KeyboardInterrupt:
# raise_task_timeout will raise a KeyboardInterrupt when the timeout
# expires. Catch the exception and raise TaskTimeout
raise TaskTimeout("Timed out polling task {0}".format(task_id))
finally:
timer.cancel()
def test_positive_build_pxe_default(self):
"""Call the "build_pxe_default" path.
@Assert: The response is a JSON payload.
@Feature: ConfigTemplate
"""
response = client.get(
entities.ConfigTemplate().path('build_pxe_default'),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
self.assertIsInstance(response.json(), dict)
def test_negative_get_unauthorized(self, entity_cls):
"""GET an entity-dependent path without credentials.
:id: 49127c71-55a2-42d1-b418-59229e9bad00
:parametrized: yes
:expectedresults: HTTP 401 is returned
:CaseImportance: Critical
"""
logger.info('test_get_unauthorized arg: %s', entity_cls)
response = client.get(entity_cls().path(), auth=(), verify=False)
assert http.client.UNAUTHORIZED == response.status_code
def test_positive_build_pxe_default(self):
"""Call the "build_pxe_default" path.
@Assert: The response is a JSON payload.
@Feature: ConfigTemplate
"""
response = client.get(
entities.ConfigTemplate().path('build_pxe_default'),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
self.assertIsInstance(response.json(), dict)
def test_positive_get_status_code(self):
"""GET ``api/v2`` and examine the response.
:id: 9d9c1afd-9158-419e-9a6e-91e9888f0c04
:expectedresults: HTTP 200 is returned with an ``application/json``
content-type
"""
response = client.get(self.path,
auth=settings.server.get_credentials(),
verify=False)
self.assertEqual(response.status_code, http.client.OK)
self.assertIn('application/json', response.headers['content-type'])
def test_positive_get_status_code(self):
"""GET ``api/v2`` and examine the response.
@Feature: API
@Assert: HTTP 200 is returned with an ``application/json`` content-type
"""
response = client.get(
self.path,
auth=settings.server.get_credentials(),
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
self.assertIn('application/json', response.headers['content-type'])
def test_positive_get_releases_content(self):
"""Get an activation key's releases. Check response contents.
@Assert: A list of results is returned.
@Feature: ActivationKey
"""
act_key = entities.ActivationKey().create()
response = client.get(
act_key.path('releases'),
auth=settings.server.get_credentials(),
verify=False,
).json()
self.assertIn('results', response.keys())
self.assertEqual(type(response['results']), list)
def test_positive_get_status_code(self):
"""GET ``api/v2`` and examine the response.
@Feature: API
@Assert: HTTP 200 is returned with an ``application/json`` content-type
"""
response = client.get(
self.path,
auth=settings.server.get_credentials(),
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
self.assertIn('application/json', response.headers['content-type'])
def read_raw(self):
"""Get information about the current entity.
Send an HTTP GET request to :meth:`Entity.path`. Return the response.
Do not check the response for any errors, such as an HTTP 4XX or 5XX
status code.
:return: A ``requests.response`` object.
"""
return client.get(
self.path('self'),
auth=self._server_config.auth,
verify=self._server_config.verify,
)
def test_positive_get_releases_content(self):
"""Get an activation key's releases. Check response contents.
:id: 2fec3d71-33e9-40e5-b934-90b03afc26a1
:expectedresults: A list of results is returned.
:CaseLevel: Integration
"""
act_key = entities.ActivationKey().create()
response = client.get(
act_key.path('releases'), auth=settings.server.get_credentials(), verify=False
).json()
self.assertIn('results', response.keys())
self.assertEqual(type(response['results']), list)
def read_raw(self, auth=None):
"""Get information about the current entity.
Send an HTTP GET request to :meth:`Entity.path`. Return the response.
Do not check the response for any errors, such as an HTTP 4XX or 5XX
status code.
:param tuple auth: A ``(username, password)`` tuple used when accessing
the API. If ``None``, the credentials provided by
:func:`robottelo.common.helpers.get_server_credentials` are used.
:return: A ``requests.response`` object.
"""
if auth is None:
auth = helpers.get_server_credentials()
return client.get(self.path(), auth=auth, verify=False)
def test_positive_get_status_code(self):
"""GET ``api/v2`` and examine the response.
:id: 9d9c1afd-9158-419e-9a6e-91e9888f0c04
:expectedresults: HTTP 200 is returned with an ``application/json``
content-type
"""
response = client.get(
self.path,
auth=settings.server.get_credentials(),
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
self.assertIn('application/json', response.headers['content-type'])
def test_positive_get_search(self):
"""@Test: GET ``api/v2/hosts`` and specify the ``search`` parameter.
@Feature: Host
@Assert: HTTP 200 is returned, along with ``search`` term.
"""
query = gen_string('utf8', gen_integer(1, 100))
response = client.get(
entities.Host().path(),
auth=settings.server.get_credentials(),
data={u'search': query},
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
self.assertEqual(response.json()['search'], query)
def test_positive_get_releases_status_code(self):
"""Get an activation key's releases. Check response format.
:id: e1ea4797-8d92-4bec-ae6b-7a26599825ab
:expectedresults: HTTP 200 is returned with an ``application/json``
content-type
:CaseLevel: Integration
"""
act_key = entities.ActivationKey().create()
path = act_key.path('releases')
response = client.get(path, auth=settings.server.get_credentials(), verify=False)
status_code = http.client.OK
self.assertEqual(status_code, response.status_code)
self.assertIn('application/json', response.headers['content-type'])
def test_positive_build_pxe_default(self):
"""Call the "build_pxe_default" path.
:id: ca19d9da-1049-4b39-823b-933fc1a0cebd
:expectedresults: The response is a JSON payload.
:CaseLevel: Integration
"""
response = client.get(
entities.ConfigTemplate().path('build_pxe_default'),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
self.assertIsInstance(response.json(), dict)
def test_negative_get_with_no_args(self):
"""Issue an HTTP GET to the base content view filters path.
:id: da29fd90-cd96-49f9-b94e-71d4e3a35a57
:expectedresults: An HTTP 200 response is received if a GET request is
issued with no arguments specified.
:CaseLevel: Integration
"""
response = client.get(
entities.AbstractContentViewFilter().path(),
auth=settings.server.get_credentials(),
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
def test_negative_get_unauthorized(self):
"""GET an entity-dependent path without credentials.
:id: 49127c71-55a2-42d1-b418-59229e9bad00
:expectedresults: HTTP 401 is returned
:CaseImportance: Critical
"""
exclude_list = (entities.ActivationKey,) # need organization_id or environment_id
test_entities = self.get_entities_for_unauthorized(valid_entities(), exclude_list)
for entity_cls in test_entities:
with self.subTest(entity_cls):
self.logger.info('test_get_unauthorized arg: %s', entity_cls)
response = client.get(entity_cls().path(), auth=(), verify=False)
self.assertEqual(http.client.UNAUTHORIZED, response.status_code)
def test_positive_build_pxe_default(self):
"""Call the "build_pxe_default" path.
:id: ca19d9da-1049-4b39-823b-933fc1a0cebd
:expectedresults: The response is a JSON payload.
:CaseLevel: Integration
"""
response = client.get(
entities.ConfigTemplate().path('build_pxe_default'),
auth=settings.server.get_credentials(),
verify=False,
)
response.raise_for_status()
self.assertIsInstance(response.json(), dict)
def test_negative_get_with_no_args(self):
"""Issue an HTTP GET to the base content view filters path.
:id: da29fd90-cd96-49f9-b94e-71d4e3a35a57
:expectedresults: An HTTP 200 response is received if a GET request is
issued with no arguments specified.
:CaseLevel: Integration
"""
response = client.get(
entities.AbstractContentViewFilter().path(),
auth=settings.server.get_credentials(),
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
def test_positive_get_per_page(self):
"""GET ``api/v2/hosts`` and specify the ``per_page`` parameter.
@id: 9086f41c-b3b9-4af2-b6c4-46b80b4d1cfd
@Assert: HTTP 200 is returned, along with per ``per_page`` value.
"""
per_page = gen_integer(1, 1000)
response = client.get(
entities.Host().path(),
auth=settings.server.get_credentials(),
data={u'per_page': per_page},
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
self.assertEqual(response.json()['per_page'], per_page)
def test_positive_get_search(self):
"""GET ``api/v2/hosts`` and specify the ``search`` parameter.
@id: d63f87e5-66e6-4886-8b44-4129259493a6
@Assert: HTTP 200 is returned, along with ``search`` term.
"""
query = gen_string('utf8', gen_integer(1, 100))
response = client.get(
entities.Host().path(),
auth=settings.server.get_credentials(),
data={u'search': query},
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
self.assertEqual(response.json()['search'], query)
def test_positive_get_per_page(self):
"""@Test: GET ``api/v2/hosts`` and specify the ``per_page`` parameter.
@Feature: Host
@Assert: HTTP 200 is returned, along with per ``per_page`` value.
"""
per_page = gen_integer(1, 1000)
response = client.get(
entities.Host().path(),
auth=settings.server.get_credentials(),
data={u'per_page': per_page},
verify=False,
)
self.assertEqual(response.status_code, http_client.OK)
self.assertEqual(response.json()['per_page'], per_page)
def test_positive_get_releases_content(self):
"""Get an activation key's releases. Check response contents.
:id: 2fec3d71-33e9-40e5-b934-90b03afc26a1
:expectedresults: A list of results is returned.
:CaseLevel: Integration
"""
act_key = entities.ActivationKey().create()
response = client.get(
act_key.path('releases'),
auth=settings.server.get_credentials(),
verify=False,
).json()
self.assertIn('results', response.keys())
self.assertEqual(type(response['results']), list)
def test_positive_get_releases_status_code(self):
"""Get an activation key's releases. Check response format.
@Assert: HTTP 200 is returned with an ``application/json`` content-type
@Feature: ActivationKey
"""
act_key = entities.ActivationKey().create()
path = act_key.path('releases')
response = client.get(
path,
auth=settings.server.get_credentials(),
verify=False,
)
status_code = http_client.OK
self.assertEqual(status_code, response.status_code)
self.assertIn('application/json', response.headers['content-type'])
def test_negative_get_with_bad_args(self):
"""Issue an HTTP GET to the base content view filters path.
:id: e6fea726-930b-4b74-b784-41528811994f
:expectedresults: An HTTP 200 response is received if a GET request is
issued with bad arguments specified.
:CaseLevel: Integration
"""
response = client.get(
entities.AbstractContentViewFilter().path(),
auth=settings.server.get_credentials(),
verify=False,
data={'foo': 'bar'},
)
self.assertEqual(response.status_code, http_client.OK)
def test_negative_get_with_bad_args(self):
"""Issue an HTTP GET to the base content view filters path.
:id: e6fea726-930b-4b74-b784-41528811994f
:expectedresults: An HTTP 200 response is received if a GET request is
issued with bad arguments specified.
:CaseLevel: Integration
"""
response = client.get(
entities.AbstractContentViewFilter().path(),
auth=settings.server.get_credentials(),
verify=False,
data={'foo': 'bar'},
)
self.assertEqual(response.status_code, http_client.OK)
def test_get_status_code(self):
"""@Test: Create a system and GET it.
@Feature: System APIs
@Assert: HTTP 200 is returned with an ``application/json`` content-type
"""
system = System(uuid=System().create_json()['uuid'])
logger.debug('system uuid: {0}'.format(system.uuid))
response = client.get(
system.path(),
auth=get_server_credentials(),
verify=False,
)
self.assertEqual(httplib.OK, response.status_code)
self.assertIn('application/json', response.headers['content-type'])
def test_get_all(self):
"""@Test: Get ``katello/api/v2/environments`` and specify just an
organization ID.
@Feature: LifecycleEnvironment
@Assert: HTTP 200 is returned with an ``application/json`` content-type
"""
org_attrs = entities.Organization().create()
response = client.get(
entities.LifecycleEnvironment().path(),
auth=get_server_credentials(),
data={u'organization_id': org_attrs['id']},
verify=False,
)
self.assertEqual(response.status_code, httplib.OK)
self.assertIn('application/json', response.headers['content-type'])
