def setUpClass(cls):
"""Create an organization and product which can be re-used in tests."""
super(DockerContainerTestCase, cls).setUpClass()
cls.org = entities.Organization().create()
cls.cr_internal = entities.DockerComputeResource(
name=gen_string('alpha'),
organization=[cls.org],
url=settings.docker.get_unix_socket_url(),
).create()
cls.cr_external = entities.DockerComputeResource(
name=gen_string('alpha'),
organization=[cls.org],
url=settings.docker.external_url,
).create()
install_katello_ca()
def test_positive_list_containers(session, module_org, module_loc):
"""Create a Docker-based Compute Resource then list its running containers.
:id: ebac82ed-5a29-4a06-8aae-bd5b08f60fba
:expectedresults: Compute Resource can be created, listed and existing
running instances can be listed.
:BZ: 1466240, 1478966
:CaseLevel: Integration
"""
compute_resource = entities.DockerComputeResource(
location=[module_loc],
organization=[module_org],
url=settings.docker.external_url,
).create()
containers = [
entities.DockerHubContainer(
compute_resource=compute_resource,
location=[module_loc],
organization=[module_org],
).create() for _ in range(3)
]
with session:
for container in containers:
assert container.name in session.computeresource.search_container(
compute_resource.name, container.name)[0]['Name']
def test_positive_list_containers_internal(self):
"""Create a Docker-based Compute Resource in the Satellite 6
instance then list its running containers.
@Assert: Compute Resource can be created and existing instances can be
listed.
@Feature: Docker
"""
for url in (settings.docker.external_url,
settings.docker.get_unix_socket_url()):
with self.subTest(url):
compute_resource = entities.DockerComputeResource(
organization=[self.org],
url=url,
).create()
self.assertEqual(compute_resource.url, url)
self.assertEqual(len(entities.AbstractDockerContainer(
compute_resource=compute_resource).search()), 0)
container = entities.DockerHubContainer(
command='top',
compute_resource=compute_resource,
organization=[self.org],
).create()
result = entities.AbstractDockerContainer(
compute_resource=compute_resource).search()
self.assertEqual(len(result), 1)
self.assertEqual(result[0].name, container.name)
def test_positive_update_docker_compresource(self):
"""Update location with new Docker compute resource
@Assert: Location updated successfully and has correct Docker compute
resource assigned
@Feature: Location - Update
"""
location = entities.Location(
compute_resource=[entities.DockerComputeResource().create()],
).create()
test_cr = entities.DockerComputeResource().create()
location.compute_resource = [test_cr]
self.assertEqual(
location.update(['compute_resource']).compute_resource[0].id,
test_cr.id
)
self.assertEqual(
location.compute_resource[0].read().provider, 'Docker')
def test_positive_update_docker_compresource(self):
"""Update location with new Docker compute resource
@id: 01ee537e-1629-44ab-b8f1-bb9a304050d6
@Assert: Location updated successfully and has correct Docker compute
resource assigned
@CaseLevel: Integration
"""
location = entities.Location(compute_resource=[
entities.DockerComputeResource().create()
], ).create()
test_cr = entities.DockerComputeResource().create()
location.compute_resource = [test_cr]
self.assertEqual(
location.update(['compute_resource']).compute_resource[0].id,
test_cr.id)
self.assertEqual(location.compute_resource[0].read().provider,
'Docker')
def test_positive_create_with_docker_compresource(self):
"""Create new location with Docker compute resource assigned to
it
@Assert: Location created successfully and has correct Docker compute
resource assigned to it
@Feature: Location
"""
test_cr = entities.DockerComputeResource().create()
location = entities.Location(compute_resource=[test_cr]).create()
self.assertEqual(location.compute_resource[0].id, test_cr.id)
self.assertEqual(
location.compute_resource[0].read().provider, 'Docker')
def test_negative_create_external(self):
"""Create a Docker-based Compute Resource using an external
Docker-enabled system.
:id: f3542272-13db-4a49-bc27-d1137144cf41
:expectedresults: Compute Resource is not created.
"""
for name in valid_data_list():
with self.assertRaises(HTTPError):
entities.DockerComputeResource(
name=name,
url=settings.docker.external_url,
).create()
def test_negative_create_internal(self):
"""Create a Docker-based Compute Resource in the Satellite 6
instance.
:id: fb9c2272-13db-4a49-bc27-d1137172df41
:expectedresults: Compute Resource is not created.
"""
for name in valid_data_list():
with self.assertRaises(HTTPError):
entities.DockerComputeResource(
name=name,
url=settings.docker.get_unix_socket_url(),
).create()
def test_positive_create_with_docker_compresource(self):
"""Create new location with Docker compute resource assigned to
it
@id: 0c55292b-d6ff-45e3-a065-d6a2c8ba2469
@Assert: Location created successfully and has correct Docker compute
resource assigned to it
@CaseLevel: Integration
"""
test_cr = entities.DockerComputeResource().create()
location = entities.Location(compute_resource=[test_cr]).create()
self.assertEqual(location.compute_resource[0].id, test_cr.id)
self.assertEqual(location.compute_resource[0].read().provider,
'Docker')
def test_positive_delete(self):
"""Create a Docker-based Compute Resource then delete it.
@Assert: Compute Resource can be created, listed and deleted.
@Feature: Docker
"""
for url in (settings.docker.external_url,
settings.docker.get_unix_socket_url()):
with self.subTest(url):
resource = entities.DockerComputeResource(url=url).create()
self.assertEqual(resource.url, url)
self.assertEqual(resource.provider, DOCKER_PROVIDER)
resource.delete()
with self.assertRaises(HTTPError):
resource.read()
def test_positive_create_with_provider(self):
"""Create compute resources with different providers. Testing only
Libvirt and Docker as other providers require valid credentials
:id: f61c66c9-15f8-4b00-9e53-7ebfb09397cc
:expectedresults: Compute resources are created with expected providers
:CaseImportance: Critical
"""
for entity in (entities.DockerComputeResource(),
entities.LibvirtComputeResource()):
with self.subTest(entity):
entity.location = [self.loc]
entity.organization = [self.org]
result = entity.create()
self.assertEqual(result.provider, entity.provider)
def module_container_host(module_org, module_loc):
with VirtualMachine(
source_image=settings.docker.docker_image,
tag='docker'
) as docker_host:
docker_host.install_katello_ca()
compute_resource = entities.DockerComputeResource(
location=[module_loc],
organization=[module_org],
name=gen_string('alpha'),
url='http://{0}:2375'.format(docker_host.ip_addr),
).create()
lce = entities.LifecycleEnvironment(organization=module_org).create()
repo = entities.Repository(
content_type='docker',
docker_upstream_name=DOCKER_UPSTREAM_NAME,
product=entities.Product(organization=module_org).create(),
url=DOCKER_REGISTRY_HUB,
).create()
repo.sync()
content_view = entities.ContentView(
composite=False,
organization=module_org,
repository=[repo],
).create()
content_view.publish()
cvv = content_view.read().version[0].read()
promote(cvv, lce.id)
yield SimpleNamespace(
compute_resource=compute_resource,
compute_resource_name=compute_resource.name + ' (Docker)',
content_view=content_view,
content_view_version=cvv,
host=docker_host,
lce=lce,
location=module_loc,
organization=module_org,
repository=repo,
)
# deleting all containers before compute resource cleanup, as otherwise it won't be
# possible to access the list of containers on UI
existing_containers = entities.AbstractDockerContainer(
compute_resource=compute_resource).search()
for container in existing_containers:
container.delete()
def test_positive_create_external(self):
"""Create a Docker-based Compute Resource using an external
Docker-enabled system.
@Assert: Compute Resource can be created and listed.
@Feature: Docker
"""
for name in valid_data_list():
with self.subTest(name):
compute_resource = entities.DockerComputeResource(
name=name,
url=settings.docker.external_url,
).create()
self.assertEqual(compute_resource.name, name)
self.assertEqual(compute_resource.provider, DOCKER_PROVIDER)
self.assertEqual(
compute_resource.url, settings.docker.external_url)
def test_negative_docker_host_setup_compresource(self):
"""Setup a docker host VM + compute resource
:id: f3575972-13db-4a49-bc27-d1137172df41
:expectedresults: Docker as compute resource is not setup successfully
"""
docker_image = settings.docker.docker_image
self.docker_host = VirtualMachine(source_image=docker_image,
tag=u'docker')
self.addCleanup(vm_cleanup, self.docker_host)
self.docker_host.create()
self.docker_host.install_katello_ca()
with self.assertRaises(HTTPError):
self.compute_resource = entities.DockerComputeResource(
name=gen_string('alpha'),
organization=[self.org],
url='http://{0}:2375'.format(self.docker_host.ip_addr),
).create()
def test_positive_create_internal(self):
"""Create a Docker-based Compute Resource in the Satellite 6
instance.
@Assert: Compute Resource can be created and listed.
@Feature: Docker
"""
for name in valid_data_list():
with self.subTest(name):
compute_resource = entities.DockerComputeResource(
name=name,
url=settings.docker.get_unix_socket_url(),
).create()
self.assertEqual(compute_resource.name, name)
self.assertEqual(compute_resource.provider, DOCKER_PROVIDER)
self.assertEqual(
compute_resource.url,
settings.docker.get_unix_socket_url()
)
def test_positive_update_internal(self):
"""Create a Docker-based Compute Resource in the Satellite 6
instance then edit its attributes.
@Assert: Compute Resource can be created, listed and its attributes can
be updated.
@Feature: Docker
"""
for url in (settings.docker.external_url,
settings.docker.get_unix_socket_url()):
with self.subTest(url):
compute_resource = entities.DockerComputeResource(
organization=[self.org],
url=url,
).create()
self.assertEqual(compute_resource.url, url)
compute_resource.url = gen_url()
self.assertEqual(
compute_resource.url,
compute_resource.update(['url']).url,
)
def test_pre_scenario_containers_support_removal(self):
"""Pre-upgrade scenario test to verify containers created and run
before upgrade
:id: preupgrade-f6de07ae-14c7-4452-9cb1-cafe2aa648ae
:steps:
1. Create docker host
2. Create and run container from dockerhub
3. Create and run container from external registry
:expectedresults:
1. Docker host is created
2. Container from dockerhub is created and running
3. Container from external registry is created and running
"""
rh_registry_available = not bz_bug_is_open(1703397)
repo_name = 'rhel'
compute_resource_name = gen_string('alpha')
registry_url = settings.docker.external_registry_1
org = entities.Organization().create()
docker_host = VirtualMachine(source_image=settings.docker.docker_image,
tag=u'docker')
docker_host.create()
try:
docker_host.install_katello_ca()
compute_resource = entities.DockerComputeResource(
name=compute_resource_name,
organization=[org],
url='http://{0}:2375'.format(docker_host.ip_addr),
).create()
# Only one registry with given URL can exist on Satellite,
# so search for it first and create it only if necessary
try:
registry = entities.Registry().search(
filters={'url': registry_url})[0]
except IndexError:
registry = entities.Registry(
url=registry_url,
organization=[org],
).create()
# container from dockerhub
dockerhub_container = entities.DockerHubContainer(
command='sleep inf',
compute_resource=compute_resource,
organization=[org],
).create()
self.assertEqual(dockerhub_container.compute_resource.id,
compute_resource.id)
# container from external registry
if rh_registry_available:
external_container = entities.DockerRegistryContainer(
command='sleep inf',
compute_resource=compute_resource,
organization=[org],
registry=registry,
repository_name=repo_name,
).create()
self.assertEqual(external_container.compute_resource.id,
compute_resource.id)
self.assertEqual(external_container.registry.id, registry.id)
self.assertEqual(external_container.repository_name, repo_name)
running_containers = docker_host.run('docker ps')
self.assertEqual(running_containers.return_code, 0)
self.assertTrue(
any(dockerhub_container.name in line
for line in running_containers.stdout))
if rh_registry_available:
self.assertTrue(
any(external_container.name in line
for line in running_containers.stdout))
ext_container_name = external_container.name if rh_registry_available else ''
scenario_dict = {
self.__class__.__name__: {
'rh_registry_available': rh_registry_available,
'docker_host': docker_host.hostname,
'dockerhub_container': dockerhub_container.name,
'external_container': ext_container_name,
}
}
create_dict(scenario_dict)
except Exception as exp:
self._vm_cleanup(hostname=docker_host.hostname)
raise Exception(exp)
def module_docker_cr(module_org):
docker_url = settings.docker.external_url
return entities.DockerComputeResource(
organization=[module_org],
url=docker_url,
).create()
