def test_docker_squashing_parameters(mocker):
builder = DockerBuilder(
Map(merge_two_dicts({'target': 'something'},
{'tags': ['foo', 'bar']})))
# None is fine here, default values for params are tested in different place
assert builder.params.no_squash == None
docker_client_class = mocker.patch(
'cekit.builders.docker_builder.APIClientClass')
squash_class = mocker.patch('cekit.builders.docker_builder.Squash')
squash = squash_class.return_value
docker_client = docker_client_class.return_value
mocker.patch.object(builder,
'_build_with_docker',
return_value="1654234sdf56")
builder.generator = Map({'image': {'from': 'FROM'}})
builder.run()
squash_class.assert_called_once_with(cleanup=True,
docker=docker_client,
from_layer="FROM",
image="1654234sdf56",
log=logging.getLogger('cekit'))
squash.run.assert_called_once_with()
builder._build_with_docker.assert_called_once_with(docker_client)
def test_docker_client_build_with_failure(mocker, caplog):
caplog.set_level(logging.DEBUG, logger="cekit")
builder = DockerBuilder(Map(merge_two_dicts({'target': 'something'}, {'tags': ['foo', 'bar']})))
docker_client_class = mocker.patch('cekit.builders.docker_builder.APIClientClass')
squash_class = mocker.patch('cekit.builders.docker_builder.Squash')
squash = squash_class.return_value
docker_client = docker_client_class.return_value
docker_client_build = mocker.patch.object(
docker_client, 'build', return_value=docker_fail_output)
builder.generator = Map({'image': {'from': 'FROM'}})
with pytest.raises(CekitError) as exception:
builder.run()
assert "Image build failed, see logs above." in str(exception.value)
squash_class.assert_not_called()
squash.run.assert_not_called()
docker_client_build.assert_called_once_with(
decode=True, path='something/image', pull=None, rm=True)
assert "Docker: Step 3/159 : COPY modules /tmp/scripts/" in caplog.text
assert "You can look inside the failed image by running 'docker run --rm -ti 81a88b63f47f bash'" in caplog.text
def test_osbs_builder_run_koji(mocker):
check_output = mocker.patch.object(
subprocess,
'check_output',
autospec=True,
side_effect=[
b'ssh://*****:*****@something.redhat.com/containers/openjdk',
b'c5a0731b558c8a247dd7f85b5f54462cd5b68b23', b'12345'
])
builder = create_builder_object(mocker, 'osbs', {}, {
'redhat': False,
'target': 'something'
})
builder.generator = Map({'image': Map({})})
mocker.patch.object(builder, '_wait_for_osbs_task')
builder.dist_git.branch = "some-branch"
builder.run()
check_output.assert_has_calls([
call(['git', 'config', '--get', 'remote.origin.url']),
call(['git', 'rev-parse', 'HEAD']),
call([
'/usr/bin/koji', 'call', '--python', 'buildContainer', '--kwargs',
"{'src': 'git://something.redhat.com/containers/openjdk#c5a0731b558c8a247dd7f85b5f54462cd5b68b23', 'target': 'some-branch-containers-candidate', 'opts': {'scratch': True, 'git_branch': 'some-branch', 'yum_repourls': []}}"
])
])
builder._wait_for_osbs_task.assert_called_once_with('12345')
def test_docker_squashing_disabled_dependencies(mocker, tmpdir, caplog):
caplog.set_level(logging.DEBUG, logger="cekit")
result = "Required CEKit library 'docker-squash' was found as a 'docker_squash' module"
image_descriptor = {
'schema_version': 1,
'from': 'centos:latest',
'name': 'test/image',
'version': '1.0',
'labels': [{'name': 'foo', 'value': 'bar'}, {'name': 'labela', 'value': 'a'}]
}
builder = create_builder_object(
mocker, 'docker', Map
({'no_squash': True, 'tags': ['foo', 'bar']}), Map({'descriptor': yaml.dump(image_descriptor), 'target': str(tmpdir)}))
assert builder.params.no_squash is True
builder.prepare()
builder.before_build()
assert result not in caplog.text
builder = create_builder_object(
mocker, 'docker', Map
({'tags': ['foo', 'bar']}), Map({'descriptor': yaml.dump(image_descriptor), 'target': str(tmpdir)}))
assert builder.params.no_squash is None
builder.prepare()
builder.before_build()
assert result in caplog.text
def test_docker_client_build(mocker, caplog):
caplog.set_level(logging.DEBUG, logger="cekit")
builder = DockerBuilder(Map({'target': 'something'}),
Map({'tags': ['foo', 'bar']}))
docker_client_class = mocker.patch(
'cekit.builders.docker_builder.APIClientClass')
squash_class = mocker.patch('cekit.builders.docker_builder.Squash')
squash = squash_class.return_value
docker_client = docker_client_class.return_value
docker_client_build = mocker.patch.object(
docker_client, 'build', return_value=docker_success_output)
builder.generator = Map({'image': {'from': 'FROM'}})
builder.run()
squash_class.assert_called_once_with(cleanup=True,
docker=docker_client,
from_layer="FROM",
image="985573b8bb7b",
log=logging.getLogger('cekit'))
squash.run.assert_called_once_with()
docker_client_build.assert_called_once_with(path='something/image',
pull=None,
rm=True)
assert "Docker: This system is not receiving updates. You can use subscription-manager on the host to register and assign subscriptions." in caplog.text
assert "Image built and available under following tags: foo, bar" in caplog.text
def test_module_processing_fail_when_no_modules_of_specified_name_can_be_found(
):
image = Image(
yaml.safe_load("""
from: foo
name: test/foo
version: 1.9
"""), 'foo')
module_a = Module(
yaml.safe_load("""
name: org.test.module.a
version: 1.0
"""), 'path', 'artifact_path')
module_registry = ModuleRegistry()
module_registry.add_module(module_a)
resulting_install_list = OrderedDict()
to_install_list = [
Map({
'name': 'org.test.module.a',
'version': '1.0'
}),
Map({'name': 'org.test.module.b'})
]
with pytest.raises(CekitError) as excinfo:
image.process_install_list(image, to_install_list,
resulting_install_list, module_registry)
assert "There are no modules with 'org.test.module.b' name available" in str(
excinfo.value)
def test_module_processing_modules_with_multiple_versions(caplog):
caplog.set_level(logging.DEBUG, logger="cekit")
image = Image(
yaml.safe_load("""
from: foo
name: test/foo
version: 1.9
"""), 'foo')
module_a = Module(
yaml.safe_load("""
name: org.test.module.a
version: 1.0
"""), 'path', 'artifact_path')
module_b = Module(
yaml.safe_load("""
name: org.test.module.b
version: 1.0
"""), 'path', 'artifact_path')
module_b_1 = Module(
yaml.safe_load("""
name: org.test.module.b
version: 1.1
"""), 'path', 'artifact_path')
module_registry = ModuleRegistry()
module_registry.add_module(module_a)
module_registry.add_module(module_b)
module_registry.add_module(module_b_1)
resulting_install_list = OrderedDict()
to_install_list = [
Map({
'name': 'org.test.module.a',
'version': '1.0'
}),
Map({'name': 'org.test.module.b'})
]
image.process_install_list(image, to_install_list, resulting_install_list,
module_registry)
assert resulting_install_list == OrderedDict([('org.test.module.a', {
'name': 'org.test.module.a',
'version': '1.0'
}), ('org.test.module.b', {
'name': 'org.test.module.b'
})])
assert "Module version not specified for 'org.test.module.b' module, using '1.1' default version" in caplog.text
def prepare_params(ctx, params=None):
if params is None:
params = Map({})
if ctx.parent:
prepare_params(ctx.parent, params)
params.update(ctx.params)
return params
def test_osbs_builder_run_brew_nowait(mocker):
params = {'nowait': True}
check_output = mocker.patch.object(subprocess, 'check_output', autospec=True, side_effect=[
b'ssh://*****:*****@something.redhat.com/containers/openjdk', b'c5a0731b558c8a247dd7f85b5f54462cd5b68b23', b'12345'])
builder = create_builder_object(mocker, 'osbs', params)
builder.generator = Map({'image': Map({})})
mocker.patch.object(builder, '_wait_for_osbs_task')
builder.dist_git.branch = "some-branch"
builder.run()
builder._wait_for_osbs_task.assert_not_called()
def test_osbs_builder_run_brew_target_defined_in_descriptor(mocker):
config.cfg['common'] = {'redhat': True}
check_output = mocker.patch.object(subprocess, 'check_output', autospec=True, side_effect=[
b'ssh://*****:*****@something.redhat.com/containers/openjdk', b'c5a0731b558c8a247dd7f85b5f54462cd5b68b23', b'12345'])
builder = create_builder_object(mocker, 'osbs', {})
builder.generator = Map({'image': Map({'osbs': Map({'koji_target': 'some-target'})})})
mocker.patch.object(builder, '_wait_for_osbs_task')
builder.dist_git.branch = "some-branch"
builder.run()
check_output.assert_called_with(['/usr/bin/brew', 'call', '--python', 'buildContainer', '--kwargs',
"{'src': 'git://something.redhat.com/containers/openjdk#c5a0731b558c8a247dd7f85b5f54462cd5b68b23', 'target': 'some-target', 'opts': {'scratch': True, 'git_branch': 'some-branch', 'yum_repourls': []}}"])
def test_buildah_builder_run_with_generator(mocker):
params = Map({'tags': []})
check_call = mocker.patch.object(subprocess, 'check_call')
builder = create_builder_object(mocker, 'buildah', params)
builder.generator = DockerGenerator("", "", {})
builder.generator.image = Image(yaml.safe_load("""
name: foo
version: 1.9
labels:
- name: test
value: val1
- name: label2
value: val2
envs:
- name: env1
value: env1val
"""), 'foo')
builder.run()
check_call.assert_called_once_with(['/usr/bin/buildah',
'build-using-dockerfile',
'--squash',
'-t', 'foo:1.9',
'-t', 'foo:latest',
'something/image'])
def test_module_processing_fail_when_module_not_found_for_specific_version():
image = Image(
yaml.safe_load("""
from: foo
name: test/foo
version: 1.9
"""), 'foo')
module_a = Module(
yaml.safe_load("""
name: org.test.module.a
version: 1.0
"""), 'path', 'artifact_path')
module_registry = ModuleRegistry()
module_registry.add_module(module_a)
resulting_install_list = OrderedDict()
to_install_list = [Map({'name': 'org.test.module.a', 'version': '1.1'})]
with pytest.raises(CekitError) as excinfo:
image.process_install_list(image, to_install_list,
resulting_install_list, module_registry)
assert "Module 'org.test.module.a' with version '1.1' could not be found, available versions: 1.0" in str(
excinfo.value)
def test_docker_squashing_disabled(mocker):
builder = DockerBuilder(Map({'target': 'something'}), Map(
{'no_squash': True, 'tags': ['foo', 'bar']}))
assert builder.params.no_squash == True
docker_client_class = mocker.patch('cekit.builders.docker_builder.APIClientClass')
docker_client = docker_client_class.return_value
mocker.patch.object(builder, '_build_with_docker')
mocker.patch.object(builder, '_squash')
builder._build_with_docker.return_value = "1654234sdf56"
builder.run()
builder._build_with_docker.assert_called_once_with(docker_client)
builder._squash.assert_not_called()
def test_docker_squashing_enabled(mocker):
builder = DockerBuilder(Map({'target': 'something'}), Map({'tags': ['foo', 'bar']}))
# None is fine here, default values for params are tested in different place
assert builder.params.no_squash == None
assert builder.params.tags == ['foo', 'bar']
docker_client_class = mocker.patch('cekit.builders.docker_builder.APIClientClass')
docker_client = docker_client_class.return_value
mocker.patch.object(builder, '_build_with_docker')
mocker.patch.object(builder, '_squash')
builder._build_with_docker.return_value = "1654234sdf56"
builder.run()
builder._build_with_docker.assert_called_once_with(docker_client)
builder._squash.assert_called_once_with(docker_client, "1654234sdf56")
def test_docker_build_default_tags(mocker):
builder = DockerBuilder(Map({'target': 'something'}), Map())
docker_client_class = mocker.patch('cekit.builders.docker_builder.APIClientClass')
docker_client = docker_client_class.return_value
mock_generator = mocker.patch.object(builder, 'generator')
mock_generator.get_tags.return_value = ["image/test:1.0", "image/test:latest"]
mocker.patch.object(builder, '_build_with_docker')
mocker.patch.object(builder, '_squash', return_value="112321312imageID")
builder._build_with_docker.return_value = "1654234sdf56"
builder.run()
builder._build_with_docker.assert_called_once_with(docker_client)
tag_calls = [mocker.call('112321312imageID', 'image/test', tag='1.0'),
mocker.call('112321312imageID', 'image/test', tag='latest')]
docker_client.tag.assert_has_calls(tag_calls)
def test_module_processing_simple_modules_order_to_install():
image = Image(
yaml.safe_load("""
from: foo
name: test/foo
version: 1.9
"""), 'foo')
module_a = Module(
yaml.safe_load("""
name: org.test.module.a
version: 1.0
"""), 'path', 'artifact_path')
module_b = Module(
yaml.safe_load("""
name: org.test.module.b
version: 1.0
"""), 'path', 'artifact_path')
module_registry = ModuleRegistry()
module_registry.add_module(module_a)
module_registry.add_module(module_b)
resulting_install_list = OrderedDict()
to_install_list = [
Map({
'name': 'org.test.module.a',
'version': '1.0'
}),
Map({'name': 'org.test.module.b'})
]
image.process_install_list(image, to_install_list, resulting_install_list,
module_registry)
assert resulting_install_list == OrderedDict([('org.test.module.a', {
'name': 'org.test.module.a',
'version': '1.0'
}), ('org.test.module.b', {
'name': 'org.test.module.b'
})])
def create_builder_object(mocker, builder, params, common_params={'target': 'something'}):
if 'docker' == builder:
from cekit.builders.docker_builder import DockerBuilder as BuilderImpl
elif 'osbs' == builder:
from cekit.builders.osbs import OSBSBuilder as BuilderImpl
elif 'podman' == builder:
from cekit.builders.podman import PodmanBuilder as BuilderImpl
elif 'buildah' == builder:
from cekit.builders.buildah import BuildahBuilder as BuilderImpl
else:
raise Exception("Builder engine %s is not supported" % builder)
mocker.patch('cekit.tools.decision')
builder = BuilderImpl(Map(common_params), Map(params))
builder.dist_git_dir = '/tmp'
builder.dist_git = DistGitMock()
builder.artifacts = []
return builder
def test_docker_tag(mocker):
builder = DockerBuilder(Map(merge_two_dicts({'target': 'something'}, {'tags': ['foo', 'bar']})))
docker_client_mock = mocker.Mock()
builder._tag(docker_client_mock, "image_id", ["image:latest", "host:5000/repo/image:tag"])
assert len(docker_client_mock.tag.mock_calls) == 2
docker_client_mock.tag.assert_has_calls([
mocker.call("image_id", "image", tag="latest"),
mocker.call("image_id", "host:5000/repo/image", tag="tag")
])
def prepare_params(ctx):
main_context = top_context(ctx)
common_params = Map(main_context.params)
params = Map({})
if ctx.parent:
params.update(ctx.parent.params)
params.update(ctx.params)
return (common_params, params)
def __to_map(self, dictionary):
"""
Convert provided dictionary, recursively, into a Map object.
This will make it possible to access nested elements
via properties:
res.git.url
instead of:
res.git['url]
"""
if not isinstance(dictionary, dict):
return dictionary
converted = Map()
for key in dictionary:
converted[key] = self.__to_map(dictionary[key])
return converted
def prepare():
""" Returns an initialized object of CacheCli """
return CacheCli(Map(click.get_current_context().parent.params))
def test_docker_builder_defaults():
builder = DockerBuilder(Map(merge_two_dicts({'target': 'something'}, {'tags': ['foo', 'bar']})))
assert builder.params.tags == ['foo', 'bar']
