def test_no_known_registries():
def execute_module(module_name=None, *_):
if module_name == "command":
return {
'failed': True,
}
return {
'changed': False,
}
def mock_known_docker_registries():
return []
dia = DockerImageAvailability(execute_module, task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=["docker.io"]),
),
openshift_deployment_type="openshift-enterprise",
openshift_image_tag='latest',
group_names=['nodes', 'masters'],
))
dia.known_docker_registries = mock_known_docker_registries
actual = dia.run()
assert actual['failed']
assert "Unable to retrieve any docker registries." in actual['msg']
def test_docker_image_availability(task_vars, expected_result):
def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
return {'info': {}} # TODO: this will vary depending on input parameters.
check = DockerImageAvailability(execute_module=execute_module)
result = check.run(tmp=None, task_vars=task_vars)
assert result == expected_result
def test_all_images_available_remotely(available_locally):
def execute_module(module_name, args, task_vars):
if module_name == 'docker_image_facts':
return {'images': [], 'failed': available_locally}
return {'changed': False}
result = DockerImageAvailability(execute_module=execute_module).run(
tmp=None,
task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=[
"docker.io", "registry.access.redhat.com"
]),
),
openshift_deployment_type='origin',
openshift_release='3.4',
openshift_image_tag='v3.4',
))
assert not result.get('failed', False)
def test_no_known_registries():
def execute_module(module_name=None, *_):
if module_name == "command":
return {
'failed': True,
}
return {
'changed': False,
}
def mock_known_docker_registries():
return []
dia = DockerImageAvailability(
execute_module,
task_vars=dict(
openshift=dict(common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
)),
openshift_docker_additional_registries=["docker.io"],
openshift_deployment_type="openshift-enterprise",
openshift_image_tag='latest',
group_names=['nodes', 'masters'],
))
dia.known_docker_registries = mock_known_docker_registries
actual = dia.run()
assert actual['failed']
assert "Unable to retrieve any docker registries." in actual['msg']
def test_all_images_available_locally(is_containerized, is_atomic):
def execute_module(module_name, args, task_vars):
if module_name == "yum":
return {"changed": True}
assert module_name == "docker_image_facts"
assert 'name' in args
assert args['name']
return {
'images': [args['name']],
}
result = DockerImageAvailability(execute_module=execute_module).run(
tmp=None,
task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=is_containerized,
is_atomic=is_atomic,
),
docker=dict(additional_registries=["docker.io"]),
),
openshift_deployment_type='origin',
openshift_release='v3.4',
openshift_image_tag='3.4',
))
assert not result.get('failed', False)
def test_all_images_unavailable():
def execute_module(module_name=None,
module_args=None,
tmp=None,
task_vars=None):
if module_name == "command":
return {
'failed': True,
}
return {
'changed': False,
}
check = DockerImageAvailability(execute_module=execute_module)
actual = check.run(
tmp=None,
task_vars=dict(openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=["docker.io"]),
),
openshift_deployment_type="openshift-enterprise",
openshift_release=None,
openshift_image_tag='latest'))
assert actual['failed']
assert "required Docker images are not available" in actual['msg']
def test_registry_availability(deployment_type, registries):
def execute_module(module_name=None,
module_args=None,
tmp=None,
task_vars=None):
return {
'changed': False,
}
actual = DockerImageAvailability(execute_module=execute_module).run(
tmp=None,
task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=registries),
),
openshift_deployment_type=deployment_type,
openshift_release='',
openshift_image_tag='',
))
assert not actual.get("failed", False)
def test_all_images_unavailable():
def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
if module_name == "command":
return {
'failed': True,
}
return {
'changed': False,
}
check = DockerImageAvailability(execute_module=execute_module)
actual = check.run(tmp=None, task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=["docker.io"]),
),
openshift_deployment_type="openshift-enterprise",
openshift_image_tag='latest',
group_names=['nodes', 'masters'],
))
assert actual['failed']
assert "required Docker images are not available" in actual['msg']
def test_all_images_available_locally(is_containerized, is_atomic):
def execute_module(module_name, module_args, task_vars):
if module_name == "yum":
return {"changed": True}
assert module_name == "docker_image_facts"
assert 'name' in module_args
assert module_args['name']
return {
'images': [module_args['name']],
}
result = DockerImageAvailability(execute_module=execute_module).run(tmp=None, task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=is_containerized,
is_atomic=is_atomic,
),
docker=dict(additional_registries=["docker.io"]),
),
openshift_deployment_type='origin',
openshift_image_tag='3.4',
group_names=['nodes', 'masters'],
))
assert not result.get('failed', False)
def test_available_images():
images = ['image1', 'image2']
dia = DockerImageAvailability(task_vars={})
with patch('openshift_checks.docker_image_availability.DockerImageAvailability.is_available_skopeo_image') as call_mock:
call_mock.return_value = True
images_available = dia.available_images(images)
assert images_available == images
def test_docker_image_availability(task_vars, expected_result):
def execute_module(module_name=None,
module_args=None,
tmp=None,
task_vars=None):
return {
'info': {}
} # TODO: this will vary depending on input parameters.
check = DockerImageAvailability(execute_module=execute_module)
result = check.run(tmp=None, task_vars=task_vars)
assert result == expected_result
def test_all_images_available_remotely(task_vars, available_locally):
def execute_module(module_name, *_):
if module_name == 'docker_image_facts':
return {'images': [], 'failed': available_locally}
return {}
task_vars['openshift_docker_additional_registries'] = ["docker.io", "registry.access.redhat.com"]
task_vars['openshift_image_tag'] = 'v3.4'
check = DockerImageAvailability(execute_module, task_vars)
check._module_retry_interval = 0
result = check.run()
assert not result.get('failed', False)
def test_all_images_available_remotely(task_vars, available_locally):
def execute_module(module_name, *_):
if module_name == 'docker_image_facts':
return {'images': [], 'failed': available_locally}
return {}
task_vars['openshift_docker_additional_registries'] = ["docker.io", "registry.access.redhat.com"]
task_vars['openshift_image_tag'] = 'v3.4'
check = DockerImageAvailability(execute_module, task_vars)
check._module_retry_interval = 0
result = check.run()
assert not result.get('failed', False)
def test_registry_availability(image, registries, connection_test_failed, skopeo_failed,
expect_success, expect_registries_reached):
def execute_module(module_name=None, *_):
if module_name == "wait_for":
return dict(msg="msg", failed=connection_test_failed)
elif module_name == "command":
return dict(msg="msg", failed=skopeo_failed)
check = DockerImageAvailability(execute_module, task_vars())
check._module_retry_interval = 0
available = check.is_available_skopeo_image(image, registries)
assert available == expect_success
assert expect_registries_reached == check.reachable_registries
def test_registry_availability(image, registries, connection_test_failed,
skopeo_failed, expect_success,
expect_registries_reached):
def execute_module(module_name=None, *_):
if module_name == "wait_for":
return dict(msg="msg", failed=connection_test_failed)
elif module_name == "command":
return dict(msg="msg", failed=skopeo_failed)
check = DockerImageAvailability(execute_module, task_vars())
check._module_retry_interval = 0
available = check.is_available_skopeo_image(image, registries)
assert available == expect_success
assert expect_registries_reached == check.reachable_registries
def test_skopeo_update_failure(message, extra_words):
def execute_module(module_name=None,
module_args=None,
tmp=None,
task_vars=None):
if module_name == "yum":
return {
"failed": True,
"msg": message,
"changed": False,
}
return {'changed': False}
actual = DockerImageAvailability(execute_module=execute_module).run(
tmp=None,
task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=["unknown.io"]),
),
openshift_deployment_type="openshift-enterprise",
openshift_release='',
openshift_image_tag='',
))
assert actual["failed"]
for word in extra_words:
assert word in actual["msg"]
def test_all_images_available_locally(task_vars, openshift_is_atomic):
def execute_module(module_name, module_args, *_):
if module_name == "yum":
return {}
assert module_name == "docker_image_facts"
assert 'name' in module_args
assert module_args['name']
return {
'images': [module_args['name']],
}
task_vars['openshift_is_atomic'] = openshift_is_atomic
result = DockerImageAvailability(execute_module, task_vars).run()
assert not result.get('failed', False)
def test_is_active(deployment_type, is_containerized, group_names, expect_active):
task_vars = dict(
openshift=dict(common=dict(is_containerized=is_containerized)),
openshift_deployment_type=deployment_type,
group_names=group_names,
)
assert DockerImageAvailability.is_active(task_vars=task_vars) == expect_active
def test_all_images_available_locally(task_vars, openshift_is_atomic):
def execute_module(module_name, module_args, *_):
if module_name == "yum":
return {}
assert module_name == "docker_image_facts"
assert 'name' in module_args
assert module_args['name']
return {
'images': [module_args['name']],
}
task_vars['openshift_is_atomic'] = openshift_is_atomic
result = DockerImageAvailability(execute_module, task_vars).run()
assert not result.get('failed', False)
def test_is_active(task_vars, deployment_type, openshift_is_atomic,
group_names, expect_active):
task_vars['openshift_deployment_type'] = deployment_type
task_vars['openshift_is_atomic'] = openshift_is_atomic
task_vars['group_names'] = group_names
assert DockerImageAvailability(None,
task_vars).is_active() == expect_active
def test_containerized(task_vars, expected):
task_vars.update(dict(
openshift_is_containerized=True,
openshift_deployment_type="origin",
))
assert expected == DockerImageAvailability(task_vars=task_vars).required_images()
def test_is_active(task_vars, deployment_type, is_containerized, group_names,
expect_active):
task_vars['openshift_deployment_type'] = deployment_type
task_vars['openshift']['common']['is_containerized'] = is_containerized
task_vars['group_names'] = group_names
assert DockerImageAvailability(None,
task_vars).is_active() == expect_active
def test_containerized_etcd():
task_vars = dict(
openshift_is_containerized=True,
openshift_deployment_type="origin",
group_names=['oo_etcd_to_config'],
)
expected = set(['registry.access.redhat.com/rhel7/etcd'])
assert expected == DockerImageAvailability(task_vars=task_vars).required_images()
def test_containerized(task_vars, expected):
task_vars.update(dict(
openshift_is_atomic=True,
oreg_url="docker.io/openshift/origin-${component}:${version}",
openshift_deployment_type="origin",
))
assert expected == DockerImageAvailability(task_vars=task_vars).required_images()
def test_is_active(deployment_type, is_containerized, group_names,
expect_active):
task_vars = dict(
openshift=dict(common=dict(is_containerized=is_containerized)),
openshift_deployment_type=deployment_type,
group_names=group_names,
)
assert DockerImageAvailability.is_active(
task_vars=task_vars) == expect_active
def test_all_images_unavailable(task_vars):
def execute_module(module_name=None, *args):
if module_name == "wait_for":
return {}
elif module_name == "command":
return {'failed': True}
return {} # docker_image_facts failure
task_vars['openshift_docker_additional_registries'] = ["docker.io"]
task_vars['openshift_deployment_type'] = "openshift-enterprise"
task_vars['openshift_image_tag'] = 'latest'
check = DockerImageAvailability(execute_module, task_vars)
check._module_retry_interval = 0
actual = check.run()
assert actual['failed']
assert "required container images are not available" in actual['msg']
def test_all_images_unavailable(task_vars):
def execute_module(module_name=None, *args):
if module_name == "wait_for":
return {}
elif module_name == "command":
return {'failed': True}
return {} # docker_image_facts failure
task_vars['openshift_docker_additional_registries'] = ["docker.io"]
task_vars['openshift_deployment_type'] = "openshift-enterprise"
task_vars['openshift_image_tag'] = 'latest'
check = DockerImageAvailability(execute_module, task_vars)
check._module_retry_interval = 0
actual = check.run()
assert actual['failed']
assert "required container images are not available" in actual['msg']
def test_skopeo_update_failure(task_vars, message, extra_words):
def execute_module(module_name=None, *_):
if module_name == "yum":
return {
"failed": True,
"msg": message,
}
return {}
task_vars['openshift_docker_additional_registries'] = ["unknown.io"]
task_vars['openshift_deployment_type'] = "openshift-enterprise"
check = DockerImageAvailability(execute_module, task_vars)
check._module_retry_interval = 0
actual = check.run()
assert actual["failed"]
for word in extra_words:
assert word in actual["msg"]
def test_skopeo_update_failure(task_vars, message, extra_words):
def execute_module(module_name=None, *_):
if module_name == "yum":
return {
"failed": True,
"msg": message,
}
return {}
task_vars['openshift_docker_additional_registries'] = ["unknown.io"]
task_vars['openshift_deployment_type'] = "openshift-enterprise"
check = DockerImageAvailability(execute_module, task_vars)
check._module_retry_interval = 0
actual = check.run()
assert actual["failed"]
for word in extra_words:
assert word in actual["msg"]
def test_required_images(deployment_type, openshift_is_atomic, groups, oreg_url, expected):
task_vars = dict(
openshift_is_atomic=openshift_is_atomic,
openshift_deployment_type=deployment_type,
group_names=groups,
oreg_url=oreg_url,
openshift_image_tag='vtest',
osn_image='registry.access.redhat.com/openshift3/ose-node:vtest',
)
assert expected == DockerImageAvailability(task_vars=task_vars).required_images()
def test_required_images(deployment_type, openshift_is_containerized, groups, oreg_url, expected):
task_vars = dict(
openshift_is_containerized=openshift_is_containerized,
openshift_is_atomic=False,
openshift_deployment_type=deployment_type,
group_names=groups,
oreg_url=oreg_url,
openshift_image_tag='vtest',
)
assert expected == DockerImageAvailability(task_vars=task_vars).required_images()
def test_registry_availability(deployment_type, registries):
def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
return {
'changed': False,
}
actual = DockerImageAvailability(execute_module=execute_module).run(tmp=None, task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=registries),
),
openshift_deployment_type=deployment_type,
openshift_image_tag='',
group_names=['nodes', 'masters'],
))
assert not actual.get("failed", False)
def test_all_images_available_remotely(available_locally):
def execute_module(module_name, module_args, task_vars):
if module_name == 'docker_image_facts':
return {'images': [], 'failed': available_locally}
return {'changed': False}
result = DockerImageAvailability(execute_module=execute_module).run(tmp=None, task_vars=dict(
openshift=dict(
common=dict(
service_type='origin',
is_containerized=False,
is_atomic=False,
),
docker=dict(additional_registries=["docker.io", "registry.access.redhat.com"]),
),
openshift_deployment_type='origin',
openshift_image_tag='v3.4',
group_names=['nodes', 'masters'],
))
assert not result.get('failed', False)
def test_is_available_skopeo_image():
result = {'rc': 0}
# test unauth secure and insecure
openshift_docker_insecure_registries = ['insecure.redhat.io']
task_vars = {
'openshift_docker_insecure_registries':
openshift_docker_insecure_registries
}
dia = DockerImageAvailability(task_vars=task_vars)
with patch.object(DockerImageAvailability,
'execute_module_with_retries') as m1:
m1.return_value = result
assert dia.is_available_skopeo_image(
'registry.redhat.io/openshift3/ose-pod') is True
m1.assert_called_with(
'command', {
'_uses_shell':
True,
'_raw_params':
' timeout 30 skopeo --debug inspect --tls-verify=true docker://registry.redhat.io/openshift3/ose-pod'
})
assert dia.is_available_skopeo_image(
'insecure.redhat.io/openshift3/ose-pod') is True
m1.assert_called_with(
'command', {
'_uses_shell':
True,
'_raw_params':
' timeout 30 skopeo --debug inspect --tls-verify=false docker://insecure.redhat.io/openshift3/ose-pod'
})
# test auth
task_vars = {
'oreg_auth_user': '******',
'oreg_auth_password': '******'
}
dia = DockerImageAvailability(task_vars=task_vars)
with patch.object(DockerImageAvailability,
'execute_module_with_retries') as m1:
m1.return_value = result
assert dia.is_available_skopeo_image(
'registry.redhat.io/openshift3/ose-pod') is True
m1.assert_called_with(
'command', {
'_uses_shell':
True,
'_raw_params':
' timeout 30 skopeo --debug inspect --tls-verify=true --creds=test_user:test_pass docker://registry.redhat.io/openshift3/ose-pod'
})
def test_is_active(deployment_type, is_active):
task_vars = dict(
openshift_deployment_type=deployment_type,
)
assert DockerImageAvailability.is_active(task_vars=task_vars) == is_active
def test_is_active(deployment_type, is_active):
task_vars = dict(openshift_deployment_type=deployment_type, )
assert DockerImageAvailability.is_active(task_vars=task_vars) == is_active
def test_registry_console_image(task_vars, expected):
info = DEPLOYMENT_IMAGE_INFO[task_vars["openshift_deployment_type"]]
tag = task_vars["openshift_image_tag"]
assert expected == DockerImageAvailability(task_vars=task_vars)._registry_console_image(tag, info)
