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_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_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_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_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_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_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): 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 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_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_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_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_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 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_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 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 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_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 __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']