def test_workflow():
"""
Test normal workflow.
"""
this_file = inspect.getfile(PreWatched)
mock_docker()
fake_builder = MockInsideBuilder()
flexmock(InsideBuilder).new_instances(fake_builder)
watch_pre = Watcher()
watch_prepub = Watcher()
watch_post = Watcher()
watch_exit = Watcher()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image',
prebuild_plugins=[{'name': 'pre_watched',
'args': {
'watcher': watch_pre
}}],
prepublish_plugins=[{'name': 'prepub_watched',
'args': {
'watcher': watch_prepub,
}}],
postbuild_plugins=[{'name': 'post_watched',
'args': {
'watcher': watch_post
}}],
exit_plugins=[{'name': 'exit_watched',
'args': {
'watcher': watch_exit
}}],
plugin_files=[this_file])
workflow.build_docker_image()
assert watch_pre.was_called()
assert watch_prepub.was_called()
assert watch_post.was_called()
assert watch_exit.was_called()
def test_add_labels_plugin_explicit(tmpdir, docker_tasker, auto_label,
labels_docker, labels_base,
reactor_config_map):
df = df_parser(str(tmpdir))
df.content = labels_docker
if MOCK:
mock_docker()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
setattr(workflow, 'builder', X())
flexmock(workflow, source=MockSource())
setattr(workflow.builder, 'df_path', df.dockerfile_path)
setattr(workflow.builder, 'base_image_inspect', labels_base)
prov_labels = {}
prov_labels[auto_label] = 'explicit_value'
if reactor_config_map:
make_and_store_reactor_config_map(workflow,
{'image_labels': prov_labels})
runner = PreBuildPluginsRunner(
docker_tasker, workflow, [{
'name': AddLabelsPlugin.key,
'args': {
'labels': prov_labels,
"dont_overwrite": [],
"auto_labels": [auto_label],
'aliases': {
'Build_Host': 'com.redhat.build-host'
}
}
}])
runner.run()
assert df.labels[auto_label] != 'explicit_value'
def test_add_labels_plugin_generated(tmpdir, docker_tasker, auto_label,
value_re_part, reactor_config_map):
df = df_parser(str(tmpdir))
df.content = DF_CONTENT
if MOCK:
mock_docker()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
setattr(workflow, 'builder', X())
flexmock(workflow, source=MockSource())
setattr(workflow.builder, 'df_path', df.dockerfile_path)
setattr(workflow.builder, 'base_image_inspect', LABELS_CONF_BASE)
if reactor_config_map:
make_and_store_reactor_config_map(workflow, {'image_labels': {}})
runner = PreBuildPluginsRunner(
docker_tasker, workflow, [{
'name': AddLabelsPlugin.key,
'args': {
'labels': {},
"dont_overwrite": [],
"auto_labels": [auto_label],
'aliases': {
'Build_Host': 'com.redhat.build-host'
}
}
}])
runner.run()
if value_re_part:
assert re.match(value_re_part, df.labels[auto_label])
if auto_label == "build-date":
utc_dt = datetime.datetime.utcfromtimestamp(
atomic_reactor_start_time).isoformat()
assert df.labels[auto_label] == utc_dt
def test_show_version(has_version, context_dir, build_dir,
workflow: DockerBuildWorkflow, caplog):
"""
Test atomic-reactor print version of osbs-client used to build the build json
if available
"""
version = "1.0"
flexmock(DockerfileParser, content='df_content')
this_file = inspect.getfile(UpdateMaintainerPlugin)
plugin_watcher = Watcher()
caplog.clear()
kwargs = {}
if has_version:
kwargs['client_version'] = version
workflow = DockerBuildWorkflow(
context_dir,
build_dir,
namespace=NAMESPACE,
pipeline_run_name=PIPELINE_RUN_NAME,
source=None,
plugins_conf=[{
'name': UpdateMaintainerPlugin.key,
'args': {
'watcher': plugin_watcher
}
}],
plugin_files=[this_file],
**kwargs,
)
workflow.build_docker_image()
expected_log_message = f"build json was built by osbs-client {version}"
assert any(expected_log_message in record.message
for record in caplog.records
if record.levelno == logging.DEBUG) == has_version
def prepare(self, key, value, set_labels_args=None, set_labels_kwargs=None):
if MOCK:
mock_docker()
tasker = DockerTasker()
workflow = DockerBuildWorkflow(SOURCE, "test-image")
setattr(workflow, 'builder', X())
setattr(workflow.builder, 'image_id', 'asd123')
setattr(workflow.builder, 'base_image', ImageName(repo='Fedora',
tag='22'))
setattr(workflow.builder, 'source', X())
setattr(workflow.builder.source, 'path', '/tmp')
setattr(workflow.builder.source, 'dockerfile_path', None)
expectation = (flexmock(OSBS)
.should_receive('set_labels_on_build_config'))
if set_labels_args is not None:
if set_labels_kwargs is None:
set_labels_kwargs = {}
expectation.with_args(*set_labels_args)
namespace = None
if set_labels_kwargs is not None:
namespace = set_labels_kwargs.get('namespace')
(flexmock(osbs.conf).should_call('Configuration')
.with_args(namespace=namespace, conf_file=None, verify_ssl=True, openshift_url="",
openshift_uri="", use_auth=True))
runner = PreBuildPluginsRunner(tasker, workflow, [
{
'name': CheckAndSetRebuildPlugin.key,
'args': {
'label_key': key,
'label_value': value,
'url': '',
},
}
])
return workflow, runner
def test_build(is_failed):
"""
tests docker build api plugin working
"""
flexmock(DockerfileParser, content='df_content')
mock_docker()
fake_builder = MockInsideBuilder()
flexmock(InsideBuilder).new_instances(fake_builder)
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
flexmock(CommandResult).should_receive('is_failed').and_return(is_failed)
if is_failed:
flexmock(CommandResult, error_detail="built error")
if is_failed:
with pytest.raises(PluginFailedException):
workflow.build_docker_image()
else:
workflow.build_docker_image()
assert isinstance(workflow.buildstep_result['docker_api'], BuildResult)
assert workflow.build_result
assert workflow.build_result.is_failed() == is_failed
def test_rpmqa_plugin(ignore_autogenerated):
if MOCK:
mock_docker()
tasker = DockerTasker()
workflow = DockerBuildWorkflow(SOURCE, "test-image")
setattr(workflow, 'builder', X())
setattr(workflow.builder, 'image_id', "asd123")
setattr(workflow.builder, 'base_image', ImageName(repo='fedora', tag='21'))
setattr(workflow.builder, "source", X())
setattr(workflow.builder.source, 'dockerfile_path', "/non/existent")
setattr(workflow.builder.source, 'path', "/non/existent")
flexmock(docker.Client, logs=mock_logs)
runner = PostBuildPluginsRunner(
tasker,
workflow,
[{"name": PostBuildRPMqaPlugin.key,
"args": {
'image_id': TEST_IMAGE,
"ignore_autogenerated_gpg_keys": ignore_autogenerated["ignore"]}}
])
results = runner.run()
assert results[PostBuildRPMqaPlugin.key] == ignore_autogenerated["package_list"]
def test_failed_build():
cmd_output = "spam spam spam spam spam spam spam baked beans spam spam spam and spam\n"
cmd_error = "Nobody expects the Spanish Inquisition!\n"
ib_process = flexmock(
stdout=StringIO(cmd_output + cmd_error),
poll=lambda: True,
returncode=1,
)
flexmock(subprocess).should_receive('Popen').and_return(ib_process)
flexmock(DockerfileParser, content='df_content')
fake_builder = MockInsideBuilder(image_id='abcde')
flexmock(InsideBuilder).new_instances(fake_builder)
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
with pytest.raises(PluginFailedException):
workflow.build_docker_image()
assert isinstance(workflow.build_result, BuildResult)
assert workflow.build_result.is_failed()
assert cmd_output in workflow.build_result.logs
assert cmd_error in workflow.build_result.logs
assert cmd_error in workflow.build_result.fail_reason
assert workflow.build_result.skip_layer_squash is False
def test_returndockerfile_plugin(tmpdir):
df_content = """
FROM fedora
RUN yum install -y python-django
CMD blabla"""
df = DockerfileParser(str(tmpdir))
df.content = df_content
tasker = DockerTasker()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
workflow.builder = X
workflow.builder.df_path = df.dockerfile_path
workflow.builder.df_dir = str(tmpdir)
runner = PreBuildPluginsRunner(tasker, workflow,
[{
'name': CpDockerfilePlugin.key
}])
runner.run()
assert CpDockerfilePlugin.key is not None
assert workflow.prebuild_results.get(CpDockerfilePlugin.key,
"") == df_content
def mock_environment(tmpdir, primary_images=None, annotations={}):
if MOCK:
mock_docker()
tasker = DockerTasker()
workflow = DockerBuildWorkflow(SOURCE, "test-image")
base_image_id = '123456parent-id'
setattr(workflow, '_base_image_inspect', {'Id': base_image_id})
setattr(workflow, 'builder', X())
setattr(workflow.builder, 'image_id', '123456imageid')
setattr(workflow.builder, 'base_image', ImageName(repo='Fedora', tag='22'))
setattr(workflow.builder, 'source', X())
setattr(workflow.builder, 'built_image_info', {'ParentId': base_image_id})
setattr(workflow.builder.source, 'dockerfile_path', None)
setattr(workflow.builder.source, 'path', None)
setattr(workflow, 'tag_conf', TagConf())
if primary_images:
workflow.tag_conf.add_primary_images(primary_images)
workflow.tag_conf.add_unique_image(primary_images[0])
workflow.build_result = BuildResult(image_id='123456',
annotations=annotations)
return tasker, workflow
def test_source_not_removed_for_exit_plugins():
flexmock(DockerfileParser, content='df_content')
this_file = inspect.getfile(PreRaises)
mock_docker()
fake_builder = MockInsideBuilder()
flexmock(InsideBuilder).new_instances(fake_builder)
watch_exit = Watcher()
watch_buildstep = Watcher()
workflow = DockerBuildWorkflow(SOURCE, 'test-image',
exit_plugins=[{'name': 'uses_source',
'args': {
'watcher': watch_exit,
}}],
buildstep_plugins=[{'name': 'buildstep_watched',
'args': {
'watcher': watch_buildstep,
}}],
plugin_files=[this_file])
workflow.build_docker_image()
# Make sure that the plugin was actually run
assert watch_exit.was_called()
def test_rpmqa_plugin_skip(docker_tasker): # noqa
"""
Test skipping the plugin if workflow.image_components is already set
"""
mock_docker()
workflow = DockerBuildWorkflow(TEST_IMAGE, source=SOURCE)
workflow.source = StubSource()
workflow.builder = StubInsideBuilder().for_workflow(workflow)
image_components = {'type': 'rpm', 'name': 'something'}
setattr(workflow, 'image_components', image_components)
flexmock(docker.APIClient, logs=mock_logs_raise)
runner = PostBuildPluginsRunner(docker_tasker, workflow,
[{
"name": PostBuildRPMqaPlugin.key,
"args": {
'image_id': TEST_IMAGE
}
}])
results = runner.run()
assert results[PostBuildRPMqaPlugin.key] is None
assert workflow.image_components == image_components
def test_rpmqa_plugin_exception():
tasker = DockerTasker()
workflow = DockerBuildWorkflow(SOURCE, "test-image")
setattr(workflow, 'builder', X())
setattr(workflow.builder, 'image_id', "asd123")
setattr(workflow.builder, 'base_image', ImageName(repo='fedora', tag='21'))
setattr(workflow.builder, "source", X())
setattr(workflow.builder.source, 'dockerfile_path', "/non/existent")
setattr(workflow.builder.source, 'path', "/non/existent")
mock_docker()
flexmock(docker.Client, logs=mock_logs_raise)
runner = PostBuildPluginsRunner(tasker, workflow,
[{
"name": PostBuildRPMqaPlugin.key,
"args": {
'image_id': TEST_IMAGE
}
}])
results = runner.run()
assert results is not None
assert results[PostBuildRPMqaPlugin.key] is not None
assert isinstance(results[PostBuildRPMqaPlugin.key], Exception)
def prepare(df_path, inherited_user=''):
if MOCK:
mock_docker()
tasker = DockerTasker()
workflow = DockerBuildWorkflow(SOURCE, "test-image")
setattr(workflow, 'builder', X())
setattr(workflow.builder, 'image_id', "asd123")
setattr(workflow.builder, 'df_path', str(df_path))
setattr(workflow.builder, 'df_dir', os.path.dirname(str(df_path)))
setattr(workflow.builder, 'base_image', ImageName(repo='Fedora', tag='21'))
setattr(workflow.builder, 'git_dockerfile_path', None)
setattr(workflow.builder, 'git_path', None)
setattr(workflow.builder, 'source', X())
setattr(workflow.builder.source, 'dockerfile_path', None)
setattr(workflow.builder.source, 'path', '')
inspection_data = {INSPECT_CONFIG: {'User': inherited_user}}
workflow.builder.inspect_base_image = lambda: inspection_data
(flexmock(requests.Response, content=repocontent).should_receive(
'raise_for_status').and_return(None))
(flexmock(requests, get=lambda *_: requests.Response()))
return tasker, workflow
def build_image_here(source,
image,
target_registries=None,
target_registries_insecure=False,
dont_pull_base_image=False,
**kwargs):
"""
build image from provided dockerfile (specified by `source`) in current environment
:param source: dict, where/how to get source code to put in image
:param image: str, tag for built image ([registry/]image_name[:tag])
:param target_registries: list of str, list of registries to push image to (might change in
future)
:param target_registries_insecure: bool, allow connecting to target registries over plain http
:param dont_pull_base_image: bool, don't pull or update base image specified in dockerfile
:return: BuildResults
"""
build_json = _prepare_build_json(image, source, target_registries,
target_registries_insecure,
dont_pull_base_image, **kwargs)
m = DockerBuildWorkflow(**build_json)
return m.build_docker_image()
def test_adddockerfile_nvr_from_labels(tmpdir):
df_content = """
FROM fedora
RUN yum install -y python-django
LABEL Name="jboss-eap-6-docker" "Version"="6.4" "Release"=77
CMD blabla"""
df = DockerfileParser(str(tmpdir))
df.content = df_content
tasker = DockerTasker()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
workflow.builder = X
workflow.builder.df_path = df.dockerfile_path
workflow.builder.df_dir = str(tmpdir)
runner = PreBuildPluginsRunner(tasker, workflow,
[{
'name': AddDockerfilePlugin.key
}])
runner.run()
assert AddDockerfilePlugin.key is not None
assert "ADD Dockerfile-jboss-eap-6-docker-6.4-77 /root/buildinfo/Dockerfile-jboss-eap-6-docker-6.4-77" in df.content
def test_dangling_volumes_removed(docker_tasker, request):
fake_logger = FakeLogger()
existing_logger = atomic_reactor.core.logger
def restore_logger():
atomic_reactor.core.logger = existing_logger
request.addfinalizer(restore_logger)
atomic_reactor.core.logger = fake_logger
mock_docker()
workflow = DockerBuildWorkflow(SOURCE, TEST_IMAGE)
workflow.source = StubSource()
workflow.builder = StubInsideBuilder().for_workflow(workflow)
workflow.builder.set_base_from_scratch(False)
runner = PostBuildPluginsRunner(docker_tasker, workflow,
[{
"name": PostBuildRPMqaPlugin.key,
"args": {
'image_id': TEST_IMAGE
}
}])
runner.run()
assert ("container_id = '%s'",
u'f8ee920b2db5e802da2583a13a4edbf0523ca5fff6b6d6454c1fd6db5f38014d') \
in fake_logger.debugs
expected_volumes = [u'test', u'conflict_exception', u'real_exception']
assert ("volumes = %s", expected_volumes) in fake_logger.debugs
assert ("removing volume '%s'", u'test') in fake_logger.infos
assert ("removing volume '%s'", u'conflict_exception') in fake_logger.infos
assert ("removing volume '%s'", u'real_exception') in fake_logger.infos
assert ('ignoring a conflict when removing volume %s', 'conflict_exception') in \
fake_logger.debugs
def test_plugin_errors(plugins, should_fail, should_log):
"""
Try bad plugin configuration.
"""
this_file = inspect.getfile(PreRaises)
mock_docker()
fake_builder = MockInsideBuilder()
flexmock(InsideBuilder).new_instances(fake_builder)
fake_logger = FakeLogger()
atomic_reactor.plugin.logger = fake_logger
workflow = DockerBuildWorkflow(MOCK_SOURCE,
'test-image',
plugin_files=[this_file],
**plugins)
# Find the 'watcher' parameter
watchers = [
conf.get('args', {}).get('watcher') for plugin in plugins.values()
for conf in plugin
]
watcher = [x for x in watchers if x][0]
if should_fail:
with pytest.raises(PluginFailedException):
workflow.build_docker_image()
assert not watcher.was_called()
else:
workflow.build_docker_image()
assert watcher.was_called()
if should_log:
assert len(fake_logger.errors) > 0
else:
assert len(fake_logger.errors) == 0
def test_workflow_compat(request):
"""
Some of our plugins have changed from being run post-build to
being run at exit. Let's test what happens when we try running an
exit plugin as a post-build plugin.
"""
flexmock(DockerfileParser, content='df_content')
this_file = inspect.getfile(PreWatched)
mock_docker()
fake_builder = MockInsideBuilder()
flexmock(InsideBuilder).new_instances(fake_builder)
watch_exit = Watcher()
watch_buildstep = Watcher()
fake_logger = FakeLogger()
existing_logger = atomic_reactor.plugin.logger
def restore_logger():
atomic_reactor.plugin.logger = existing_logger
request.addfinalizer(restore_logger)
atomic_reactor.plugin.logger = fake_logger
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image',
postbuild_plugins=[{'name': 'store_logs_to_file',
'args': {
'watcher': watch_exit
}}],
buildstep_plugins=[{'name': 'buildstep_watched',
'args': {
'watcher': watch_buildstep
}}],
plugin_files=[this_file])
workflow.build_docker_image()
assert watch_exit.was_called()
assert len(fake_logger.errors) > 0
def test_pull_base_image_plugin(parent_registry, df_base, expected, not_expected):
if MOCK:
mock_docker(remember_images=True)
tasker = DockerTasker()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
workflow.builder = MockBuilder()
workflow.builder.base_image = ImageName.parse(df_base)
expected = set(expected)
expected.add(df_base)
all_images = set(expected).union(not_expected)
for image in all_images:
assert not tasker.image_exists(image)
runner = PreBuildPluginsRunner(
tasker,
workflow,
[{
'name': PullBaseImagePlugin.key,
'args': {'parent_registry': parent_registry, 'parent_registry_insecure': True}
}]
)
runner.run()
for image in expected:
assert tasker.image_exists(image)
for image in not_expected:
assert not tasker.image_exists(image)
for image in all_images:
try:
tasker.remove_image(image)
except:
pass
def test_dangling_volumes_removed(docker_tasker, request): # noqa:F811
mock_docker()
fake_logger = FakeLogger()
existing_logger = atomic_reactor.core.logger
def restore_logger():
atomic_reactor.core.logger = existing_logger
request.addfinalizer(restore_logger)
atomic_reactor.core.logger = fake_logger
workflow = DockerBuildWorkflow(SOURCE, "test-image")
setattr(workflow, 'builder', X())
setattr(workflow.builder, 'image_id', "asd123")
setattr(workflow.builder, 'base_image', ImageName(repo='fedora', tag='21'))
setattr(workflow.builder, "source", X())
setattr(workflow.builder.source, 'dockerfile_path', "/non/existent")
setattr(workflow.builder.source, 'path', "/non/existent")
runner = PostBuildPluginsRunner(docker_tasker, workflow,
[{"name": PostBuildRPMqaPlugin.key,
"args": {'image_id': TEST_IMAGE}}])
runner.run()
assert ("container_id = '%s'",
u'f8ee920b2db5e802da2583a13a4edbf0523ca5fff6b6d6454c1fd6db5f38014d') \
in fake_logger.debugs
expected_volumes = [u'test', u'conflict_exception', u'real_exception']
assert ("volumes = %s", expected_volumes) in fake_logger.debugs
assert ("removing volume '%s'", u'test') in fake_logger.infos
assert ("removing volume '%s'", u'conflict_exception') in fake_logger.infos
assert ("removing volume '%s'", u'real_exception') in fake_logger.infos
assert ('ignoring a conflict when removing volume %s', 'conflict_exception') in \
fake_logger.debugs
def test_compress(self, tmpdir, caplog, method, load_exported_image,
extension):
if MOCK:
mock_docker()
tasker = DockerTasker()
workflow = DockerBuildWorkflow({
'provider': 'git',
'uri': 'asd'
}, 'test-image')
workflow.builder = X()
exp_img = os.path.join(str(tmpdir), 'img.tar')
if load_exported_image:
tarfile.open(exp_img, mode='w').close()
workflow.exported_image_sequence.append({'path': exp_img})
runner = PostBuildPluginsRunner(
tasker, workflow, [{
'name': CompressPlugin.key,
'args': {
'method': method,
'load_exported_image': load_exported_image,
},
}])
runner.run()
compressed_img = os.path.join(
workflow.source.tmpdir,
EXPORTED_COMPRESSED_IMAGE_NAME_TEMPLATE.format(extension))
assert os.path.exists(compressed_img)
metadata = workflow.exported_image_sequence[-1]
assert metadata['path'] == compressed_img
assert 'uncompressed_size' in metadata
assert isinstance(metadata['uncompressed_size'], integer_types)
assert ", ratio: " in caplog.text()
def test_url_label(tmpdir, docker_tasker, caplog, url_format, info_url):
if MOCK:
mock_docker()
plugin_labels = {}
base_labels = {INSPECT_CONFIG: {"Labels": {}}}
df = df_parser(str(tmpdir))
df.content = DF_CONTENT_LABELS
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
setattr(workflow, 'builder', X)
flexmock(workflow, base_image_inspect=base_labels)
setattr(workflow.builder, 'df_path', df.dockerfile_path)
runner = PreBuildPluginsRunner(
docker_tasker,
workflow,
[{
'name': AddLabelsPlugin.key,
'args': {
'labels': plugin_labels,
'dont_overwrite': [],
'auto_labels': [],
'info_url_format': url_format
}
}]
)
if info_url is not None:
runner.run()
assert df.labels.get("url") == info_url
else:
with pytest.raises(PluginFailedException):
runner.run()
assert AddLabelsPlugin.key is not None
def test_store_metadata_combined():
@annotation('foo')
@annotation_map('bar')
@label('spam')
@label_map('eggs')
class BP(BuildPlugin):
key = 'bp'
def run(self):
return {'bar': 1, 'eggs': 2}
tasker = object()
workflow = DockerBuildWorkflow()
p = BP(tasker, workflow)
p.run()
assert workflow.annotations == {
'foo': {'bar': 1, 'eggs': 2},
'bar': 1
}
assert workflow.labels == {
'spam': {'bar': 1, 'eggs': 2},
'eggs': 2
}
def test_add_help_no_help_file(request, tmpdir, docker_tasker, filename):
df_content = "FROM fedora"
df = df_parser(str(tmpdir))
df.content = df_content
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
workflow.builder = X
workflow.builder.df_path = df.dockerfile_path
workflow.builder.df_dir = str(tmpdir)
runner = PreBuildPluginsRunner(
docker_tasker,
workflow,
[{
'name': AddHelpPlugin.key,
'args': {'help_file': filename}
}]
)
# Runner should not crash if no help.md found
result = runner.run()
assert result == {'add_help': {
'status': AddHelpPlugin.NO_HELP_FILE_FOUND,
'help_file': filename
}}
def test_popen_cmd(image_id):
"""
tests imagebuilder build plugin working
"""
flexmock(DockerfileParser, content='df_content')
fake_builder = MockInsideBuilder(image_id=image_id)
flexmock(InsideBuilder).new_instances(fake_builder)
cmd_output = "spam spam spam spam spam spam spam baked beans spam spam spam and spam"
real_popen = subprocess.Popen
flexmock(
subprocess,
Popen=lambda *_, **kw: real_popen(['echo', '-n', cmd_output], **kw))
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
workflow.build_docker_image()
assert isinstance(workflow.buildstep_result['imagebuilder'], BuildResult)
assert workflow.build_result == workflow.buildstep_result['imagebuilder']
assert not workflow.build_result.is_failed()
assert workflow.build_result.image_id.startswith('sha256:')
assert workflow.build_result.image_id.count(':') == 1
assert workflow.build_result.skip_layer_squash
assert len(workflow.exported_image_sequence) == 1
assert cmd_output in workflow.build_result.logs
def mock_environment(base_image=None):
if MOCK:
mock_docker()
tasker = DockerTasker()
workflow = DockerBuildWorkflow(
TEST_IMAGE,
source={
"provider": "git",
"uri": "asd"
},
)
workflow.postbuild_results[TagAndPushPlugin.key] = True
workflow.tag_conf.add_primary_image(TEST_IMAGE)
workflow.push_conf.add_docker_registry(LOCALHOST_REGISTRY, insecure=True)
setattr(workflow, 'builder', X())
setattr(workflow.builder, 'image_id', INPUT_IMAGE)
setattr(workflow.builder, 'source', X())
setattr(workflow.builder.source, 'dockerfile_path', None)
setattr(workflow.builder.source, 'path', None)
base_image = ImageName.parse(IMPORTED_IMAGE_ID)
setattr(workflow.builder, 'base_image', base_image)
workflow.pulled_base_images.add(IMPORTED_IMAGE_ID)
return tasker, workflow
def mock_workflow(tmpdir):
if MOCK:
mock_docker()
workflow = DockerBuildWorkflow('test-image', source=SOURCE)
setattr(workflow, 'builder', X())
flexmock(DockerfileParser, content='df_content')
setattr(workflow.builder, 'get_built_image_info', flexmock())
flexmock(workflow.builder, get_built_image_info={'Id': 'some'})
setattr(workflow.builder, 'ensure_not_built', flexmock())
flexmock(workflow.builder, ensure_not_built=None)
setattr(workflow.builder, 'image_id', 'image-id')
setattr(workflow.builder, 'source', flexmock(
dockerfile_path='dockerfile-path',
path='path',
config=flexmock(image_build_method=None),
))
setattr(workflow.builder, 'df_path', 'df_path')
setattr(workflow.builder, 'image', flexmock())
setattr(workflow.builder.image, 'to_str', lambda: 'image')
setattr(workflow.builder, 'base_image', flexmock())
setattr(workflow.builder.base_image, 'to_str', lambda: 'base-image')
return workflow
def test_add_labels_plugin(tmpdir, docker_tasker, df_content, labels_conf_base,
labels_conf, eq_conf, dont_overwrite, aliases,
expected_output, caplog):
df = df_parser(str(tmpdir))
df.content = df_content
if MOCK:
mock_docker()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image')
setattr(workflow, 'builder', X)
flexmock(workflow, base_image_inspect=labels_conf_base)
setattr(workflow.builder, 'df_path', df.dockerfile_path)
runner = PreBuildPluginsRunner(docker_tasker, workflow,
[{
'name': AddLabelsPlugin.key,
'args': {
'labels': labels_conf,
'dont_overwrite': dont_overwrite,
'auto_labels': [],
'aliases': aliases,
'equal_labels': eq_conf,
}
}])
if isinstance(expected_output, RuntimeError):
with pytest.raises(PluginFailedException):
runner.run()
assert "plugin 'add_labels_in_dockerfile' raised an exception: RuntimeError" \
in caplog.text()
else:
runner.run()
assert AddLabelsPlugin.key is not None
assert df.content in expected_output
def test_autorebuild_stop_prevents_build():
"""
test that a plugin that raises AutoRebuildCanceledException results in actually skipped build
"""
this_file = inspect.getfile(PreWatched)
mock_docker()
fake_builder = MockInsideBuilder()
flexmock(InsideBuilder).new_instances(fake_builder)
watch_prepub = Watcher()
watch_post = Watcher()
watch_exit = Watcher()
workflow = DockerBuildWorkflow(MOCK_SOURCE, 'test-image',
prebuild_plugins=[{'name': 'stopstopstop',
'args': {
}}],
prepublish_plugins=[{'name': 'prepub_watched',
'args': {
'watcher': watch_prepub,
}}],
postbuild_plugins=[{'name': 'post_watched',
'args': {
'watcher': watch_post
}}],
exit_plugins=[{'name': 'exit_watched',
'args': {
'watcher': watch_exit
}}],
plugin_files=[this_file])
with pytest.raises(AutoRebuildCanceledException):
workflow.build_docker_image()
assert not watch_prepub.was_called()
assert not watch_post.was_called()
assert watch_exit.was_called()
assert workflow.autorebuild_canceled == True
