def test_get_receiver_list(self, monkeypatch, additional_addresses, expected_receivers):
class TagConf(object):
unique_images = []
class WF(object):
image = ImageName.parse('foo/bar:baz')
openshift_build_selflink = '/builds/blablabla'
build_process_failed = False
autorebuild_canceled = False
build_canceled = False
tag_conf = TagConf()
exit_results = {
KojiImportPlugin.key: MOCK_KOJI_BUILD_ID
}
prebuild_results = {}
plugin_workspace = {}
monkeypatch.setenv("BUILD", json.dumps({
'metadata': {
'labels': {
'koji-task-id': MOCK_KOJI_TASK_ID,
},
'name': {},
}
}))
session = MockedClientSession('', has_kerberos=True)
pathinfo = MockedPathInfo('https://koji')
flexmock(koji, ClientSession=lambda hub, opts: session, PathInfo=pathinfo)
kwargs = {
'url': 'https://something.com',
'smtp_host': 'smtp.bar.com',
'from_address': '*****@*****.**',
'additional_addresses': additional_addresses
}
workflow = WF()
openshift_map = {'url': 'https://something.com'}
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'send_to_submitter': False,
'send_to_pkg_owner': False,
'additional_addresses': additional_addresses
}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'smtp': smtp_map, 'openshift': openshift_map})
add_koji_map_in_workflow(workflow, hub_url=None, root_url='https://koji/',
ssl_certs_dir='/certs')
p = SendMailPlugin(None, workflow, **kwargs)
if expected_receivers is not None:
assert sorted(expected_receivers) == sorted(p._get_receivers_list())
else:
with pytest.raises(RuntimeError) as ex:
p._get_receivers_list()
assert str(ex.value) == 'No recipients found'
def test_should_send(self, rebuild, success, auto_canceled, manual_canceled, send_on, expected):
class WF(object):
exit_results = {
KojiImportPlugin.key: MOCK_KOJI_BUILD_ID
}
plugin_workspace = {}
kwargs = {
'smtp_host': 'smtp.bar.com',
'from_address': '*****@*****.**',
'send_on': send_on,
}
workflow = WF()
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.spam.com',
}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'smtp': smtp_map})
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(None, workflow, **kwargs)
assert p._should_send(rebuild, success, auto_canceled, manual_canceled) == expected
def test_run_ok(self, tmpdir, workflow, source_dir):
workflow.data.plugin_failed = True
receivers = ['*****@*****.**', '*****@*****.**']
dockerfile = source_dir / DOCKERFILE_FILENAME
dockerfile.write_text(MOCK_DOCKERFILE, "utf-8")
flexmock(workflow, df_path=str(dockerfile))
mock_store_metadata_results(workflow)
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[])
(flexmock(p).should_receive('_should_send')
.with_args(False, False).and_return(True))
flexmock(p).should_receive('_get_receivers_list').and_return(receivers)
flexmock(p).should_receive('_send_mail').with_args(receivers,
str, str, None)
p.run()
def test_skip_plugin(self, caplog, target, yum_repos, include_repo):
tasker, workflow = prepare()
args = {'target': target}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1})
add_koji_map_in_workflow(workflow, hub_url='', root_url='http://example.com')
workflow.user_params['include_koji_repo'] = include_repo
workflow.user_params['yum_repourls'] = yum_repos
runner = PreBuildPluginsRunner(tasker, workflow, [{
'name': KojiPlugin.key,
'args': args,
}])
runner.run()
if (not include_repo and yum_repos):
log_msg = 'there is a yum repo user parameter, skipping plugin'
else:
log_msg = 'no target provided, skipping plugin'
assert log_msg in caplog.text
def test_run_does_nothing_if_conditions_not_met(self): # noqa
class WF(object):
autorebuild_canceled = False
build_canceled = False
prebuild_results = {CheckAndSetRebuildPlugin.key: True}
image = ImageName.parse('repo/name')
build_process_failed = True
exit_results = {}
plugin_workspace = {}
workflow = WF()
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.spam.com',
}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'smtp': smtp_map})
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(None, workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[MS])
(flexmock(p).should_receive('_should_send')
.with_args(True, False, False, False).and_return(False))
flexmock(p).should_receive('_get_receivers_list').times(0)
flexmock(p).should_receive('_send_mail').times(0)
p.run()
def test_get_email_from_koji_obj(self, has_kerberos,
email_domain, expected_email,
workflow):
session = MockedClientSession('', has_kerberos=has_kerberos)
flexmock(koji, ClientSession=lambda hub, opts: session)
workflow.data.postbuild_results[KojiImportPlugin.key] = MOCK_KOJI_BUILD_ID
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'domain': email_domain,
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow, email_domain=email_domain)
koji_task_owner = get_koji_task_owner(p.session, p.koji_task_id)
try:
found_email = p._get_email_from_koji_obj(koji_task_owner)
assert expected_email == found_email
except RuntimeError as exc:
if not email_domain:
assert str(exc) == "Empty email_domain specified"
else:
assert str(exc) == "Koji task owner name is missing"
def test_include_koji_without_target(workflow, build_dir, caplog, target,
include_repo):
prepare(workflow, build_dir, include_koji_repo=include_repo)
args = {'target': target}
add_koji_map_in_workflow(workflow,
hub_url='',
root_url='http://example.com')
runner = PreBuildPluginsRunner(workflow, [{
'name': InjectYumReposPlugin.key,
'args': args,
}])
runner.run()
if not include_repo or not target:
if not include_repo:
log_msg = f"'include_koji_repo parameter is set to '{include_repo}', " \
f"not including koji repo"
else:
log_msg = 'no target provided, not adding koji repo'
else:
log_msg = "injected yum repo: /etc/yum.repos.d/target-bd4b1.repo for 'x86_64' platform"
assert log_msg in caplog.text
def test_get_receiver_list(self, additional_addresses, expected_receivers, workflow):
session = MockedClientSession('', has_kerberos=True)
pathinfo = MockedPathInfo('https://koji')
flexmock(koji, ClientSession=lambda hub, opts: session, PathInfo=pathinfo)
kwargs = {
'url': 'https://something.com',
'smtp_host': 'smtp.bar.com',
'from_address': '*****@*****.**',
'additional_addresses': additional_addresses
}
workflow.data.postbuild_results[KojiImportPlugin.key] = MOCK_KOJI_BUILD_ID
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'send_to_submitter': False,
'send_to_pkg_owner': False,
'additional_addresses': additional_addresses
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url=None, root_url='https://koji/',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow, **kwargs)
if expected_receivers is not None:
assert sorted(expected_receivers) == sorted(p._get_receivers_list())
else:
with pytest.raises(RuntimeError) as ex:
p._get_receivers_list()
assert str(ex.value) == 'No recipients found'
def create_runner(workflow,
ssl_certs=False,
principal=None,
keytab=None,
poll_interval=0.01,
proxy_user=None,
use_args=True,
koji_target='koji-target'):
args = {
'target': koji_target,
}
if poll_interval is not None:
args['poll_interval'] = poll_interval
add_koji_map_in_workflow(workflow,
hub_url='',
ssl_certs_dir='/' if ssl_certs else None,
krb_keytab=keytab,
krb_principal=principal,
proxyuser=proxy_user)
plugin_conf = {'name': KojiTagBuildPlugin.key}
if use_args:
plugin_conf['args'] = args
else:
plugin_conf['args'] = {'target': koji_target}
runner = PostBuildPluginsRunner(workflow, [plugin_conf])
return runner
def test_run_ok_and_send(self, workflow):
workflow.data.plugin_failed = True
class SMTP(object):
def sendmail(self, from_addr, to, msg):
pass
def quit(self):
pass
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.spam.com',
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
receivers = ['*****@*****.**', '*****@*****.**']
p = SendMailPlugin(workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[])
(flexmock(p).should_receive('_should_send')
.with_args(False, False).and_return(True))
flexmock(p).should_receive('_get_receivers_list').and_return(receivers)
flexmock(p).should_receive('_get_image_name_and_repos').and_return(('foobar',
['foo/bar:baz',
'foo/bar:spam']))
smtp_inst = SMTP()
flexmock(smtplib).should_receive('SMTP').and_return(smtp_inst)
p.run()
def test_send_mail(self, throws_exception, workflow):
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow, from_address='*****@*****.**', smtp_host='smtp.spam.com')
class SMTP(object):
def sendmail(self, from_addr, to, msg):
pass
def quit(self):
pass
smtp_inst = SMTP()
flexmock(smtplib).should_receive('SMTP').and_return(smtp_inst)
sendmail_chain = (flexmock(smtp_inst).should_receive('sendmail').
with_args('*****@*****.**', ['*****@*****.**'], str))
if throws_exception:
sendmail_chain.and_raise(smtplib.SMTPException, "foo")
flexmock(smtp_inst).should_receive('quit')
if throws_exception:
with pytest.raises(SMTPException) as e:
p._send_mail(['*****@*****.**'], 'subject', 'body')
assert str(e.value) == 'foo'
else:
p._send_mail(['*****@*****.**'], 'subject', 'body')
def create_runner(tasker, workflow, ssl_certs=False, principal=None,
keytab=None, poll_interval=0.01, proxy_user=None,
use_args=True, koji_target='koji-target'):
args = {
'target': koji_target,
}
if poll_interval is not None:
args['poll_interval'] = poll_interval
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1})
add_koji_map_in_workflow(workflow, hub_url='',
ssl_certs_dir='/' if ssl_certs else None,
krb_keytab=keytab,
krb_principal=principal,
proxyuser=proxy_user)
plugin_conf = {
'name': KojiTagBuildPlugin.key
}
if use_args:
plugin_conf['args'] = args
else:
plugin_conf['args'] = {'target': koji_target}
runner = ExitPluginsRunner(tasker, workflow, [plugin_conf])
return runner
def test_run_fails_to_obtain_receivers(self, workflow):
MockEnv(workflow).mock_build_outcome(failed=True)
error_addresses = ['*****@*****.**']
mock_store_metadata_results(workflow)
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'error_addresses': ['*****@*****.**'],
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[], error_addresses=error_addresses)
(flexmock(p).should_receive('_should_send')
.with_args(False, False).and_return(True))
flexmock(p).should_receive('_get_receivers_list').and_raise(RuntimeError())
flexmock(p).should_receive('_get_image_name_and_repos').and_return(('foobar',
['foo/bar:baz',
'foo/bar:spam']))
flexmock(p).should_receive('_send_mail').with_args(error_addresses, str, str, None)
p.run()
def test_run_ok(self, tmpdir, workflow, source_dir):
MockEnv(workflow).mock_build_outcome(failed=True)
receivers = ['*****@*****.**', '*****@*****.**']
mock_dockerfile(workflow)
mock_store_metadata_results(workflow)
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[])
(flexmock(p).should_receive('_should_send')
.with_args(False, False).and_return(True))
flexmock(p).should_receive('_get_receivers_list').and_return(receivers)
flexmock(p).should_receive('_send_mail').with_args(receivers,
str, str, None)
p.run()
def test_failed_logs(self, workflow, source_dir, error_type):
# just test a random combination of the method inputs and hope it's ok for other
# combinations
session = MockedClientSession('', has_kerberos=True)
pathinfo = MockedPathInfo('https://koji')
flexmock(koji, ClientSession=lambda hub, opts: session, PathInfo=pathinfo)
kwargs = {
'url': 'https://something.com',
'smtp_host': 'smtp.bar.com',
'from_address': '*****@*****.**',
'to_koji_submitter': True,
'to_koji_pkgowner': False,
}
mock_store_metadata_results(workflow)
workflow.data.plugins_results[KojiImportPlugin.key] = MOCK_KOJI_BUILD_ID
mock_dockerfile(workflow)
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'send_to_submitter': True,
'send_to_pkg_owner': False,
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow, **kwargs)
_, _, fail_logs = p._render_mail(False, False)
assert not fail_logs
def test_run_invalid_receivers(self, caplog, workflow):
workflow.data.plugin_failed = True
error_addresses = ['*****@*****.**']
mock_store_metadata_results(workflow)
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'error_addresses': ['*****@*****.**'],
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[], error_addresses=error_addresses)
(flexmock(p).should_receive('_should_send')
.with_args(False, False).and_return(True))
flexmock(p).should_receive('_get_receivers_list').and_return([])
flexmock(p).should_receive('_get_image_name_and_repos').and_return(('foobar',
['foo/bar:baz',
'foo/bar:spam']))
p.run()
assert 'no valid addresses in requested addresses. Doing nothing' in caplog.text
def run_plugin_with_args(self, workflow, plugin_args=None, organization=None,
base_from_scratch=False, custom_base_image=False,
koji_parent_build=KOJI_BUILD_ID):
plugin_args = plugin_args or {}
plugin_args.setdefault('koji_parent_build', koji_parent_build)
rcm = {'version': 1, 'registries_organization': organization,
'source_registry': {'url': 'source_registry.com'}}
workflow.conf.conf = rcm
add_koji_map_in_workflow(workflow,
hub_url=KOJI_HUB,
root_url='',
ssl_certs_dir=plugin_args.get('koji_ssl_certs_dir'))
runner = PreBuildPluginsRunner(
workflow,
[{'name': InjectParentImage.key, 'args': plugin_args}]
)
result = runner.run()
if not koji_parent_build:
return
if base_from_scratch or custom_base_image:
assert result[InjectParentImage.key] is None
else:
# Koji build ID is always used, even when NVR is given.
assert result[InjectParentImage.key] == KOJI_BUILD_ID
def test_generated_email(self, monkeypatch, has_kerberos, expected_receivers):
class TagConf(object):
unique_images = []
class WF(object):
image = ImageName.parse('foo/bar:baz')
openshift_build_selflink = '/builds/blablabla'
build_process_failed = False
tag_conf = TagConf()
exit_results = {
KojiImportPlugin.key: MOCK_KOJI_BUILD_ID
}
plugin_workspace = {}
monkeypatch.setenv("BUILD", json.dumps({
'metadata': {
'labels': {
'koji-task-id': MOCK_KOJI_TASK_ID,
},
'name': {},
}
}))
session = MockedClientSession('', has_kerberos=has_kerberos)
flexmock(koji, ClientSession=lambda hub, opts: session, PathInfo=MockedPathInfo)
kwargs = {
'url': 'https://something.com',
'smtp_host': 'smtp.bar.com',
'from_address': '*****@*****.**',
'to_koji_submitter': True,
'to_koji_pkgowner': True,
'email_domain': MOCK_EMAIL_DOMAIN
}
workflow = WF()
openshift_map = {'url': 'https://something.com'}
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'send_to_submitter': True,
'send_to_pkg_owner': True,
'domain': MOCK_EMAIL_DOMAIN,
}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'smtp': smtp_map, 'openshift': openshift_map})
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(None, workflow, **kwargs)
receivers = p._get_receivers_list()
assert sorted(receivers) == sorted(expected_receivers)
if has_kerberos:
assert p.submitter == MOCK_KOJI_SUBMITTER_EMAIL
else:
assert p.submitter == MOCK_KOJI_SUBMITTER_GENERATED
def prepare(self,
tmpdir,
labels=None,
include_target=True,
certs=False,
append=False,
reserve_build=False,
is_auto=False,
add_timestamp=None,
fetch_source=False,
scratch=None):
if labels is None:
labels = {}
workflow = flexmock()
setattr(workflow, 'builder', flexmock())
setattr(workflow, 'plugin_workspace', {})
setattr(workflow, 'reserved_build_id', None)
setattr(workflow, 'reserved_token ', None)
setattr(workflow, 'source', MockSource(tmpdir, add_timestamp))
setattr(workflow, 'prebuild_results', {CheckAndSetRebuildPlugin.key: is_auto})
setattr(workflow, 'user_params', {})
if scratch is not None:
workflow.user_params['scratch'] = scratch
if fetch_source:
workflow.prebuild_results[PLUGIN_FETCH_SOURCES_KEY] = {
'sources_for_nvr': KOJI_SOURCE_NVR
}
df = tmpdir.join('Dockerfile')
df.write('FROM base\n')
for key, value in labels.items():
df.write('LABEL {key}={value}\n'.format(key=key, value=value), mode='a')
setattr(workflow.builder, 'df_path', str(df))
kwargs = {
'tasker': None,
'workflow': workflow,
}
if include_target:
kwargs['target'] = 'foo'
if append:
kwargs['append'] = True
if certs:
tmpdir.join('cert').write('cert')
tmpdir.join('serverca').write('serverca')
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1})
add_koji_map_in_workflow(workflow, hub_url='', root_url='',
reserve_build=reserve_build,
ssl_certs_dir=str(tmpdir) if certs else None)
plugin = BumpReleasePlugin(**kwargs)
return plugin
def test_koji_recepients_exception(self, exception_location, expected_receivers, workflow):
if exception_location == 'empty_owner':
koji_build_id = None
else:
koji_build_id = MOCK_KOJI_BUILD_ID
has_kerberos = exception_location != 'empty_email_domain'
session = MockedClientSession('', has_kerberos=has_kerberos)
if exception_location == 'koji_connection':
(flexmock(session)
.should_receive('ssl_login')
.and_raise(RuntimeError, "xyz"))
elif exception_location == 'submitter':
(flexmock(session)
.should_receive('getTaskInfo')
.and_raise(RuntimeError, "xyz"))
elif exception_location == 'owner':
(flexmock(session)
.should_receive('getPackageConfig')
.and_raise(RuntimeError, "xyz"))
flexmock(koji, ClientSession=lambda hub, opts: session, PathInfo=MockedPathInfo)
kwargs = {
'url': 'https://something.com',
'smtp_host': 'smtp.bar.com',
'from_address': '*****@*****.**',
'to_koji_submitter': True,
'to_koji_pkgowner': True
}
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'send_to_submitter': True,
'send_to_pkg_owner': True,
}
if exception_location != 'empty_email_domain':
kwargs['email_domain'] = MOCK_EMAIL_DOMAIN
smtp_map['domain'] = MOCK_EMAIL_DOMAIN
workflow.data.postbuild_results[KojiImportPlugin.key] = koji_build_id
if exception_location == 'empty_submitter':
workflow.user_params['koji_task_id'] = None
else:
workflow.user_params['koji_task_id'] = MOCK_KOJI_TASK_ID
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow, **kwargs)
if not expected_receivers:
with pytest.raises(RuntimeError):
p._get_receivers_list()
else:
receivers = p._get_receivers_list()
assert sorted(receivers) == sorted(expected_receivers)
def test_skip_plugin(self, caplog, workflow):
rcm = {'version': 1, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow)
p.run()
log_msg = 'no smtp configuration, skipping plugin'
assert log_msg in caplog.text
def run_plugin_with_args(self, workflow, plugin_args=None, expect_result=True, # noqa
external_base=False, deep_inspection=True, mismatch_failure=False,
user_params=None, is_isolated=None,
pull_registries=None, source_registry=None):
plugin_args = plugin_args or {}
user_params = user_params or {}
plugin_args.setdefault('poll_interval', 0.01)
plugin_args.setdefault('poll_timeout', 1)
workflow.user_params = user_params
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
config_dict = {'version': 1,
'deep_manifest_list_inspection': deep_inspection,
'fail_on_digest_mismatch': mismatch_failure,
'skip_koji_check_for_base_image': external_base,
'platform_descriptors': [{'architecture': 'amd64', 'platform': 'x86_64'}]}
if pull_registries:
config_dict['pull_registries'] = pull_registries
if source_registry:
config_dict['source_registry'] = source_registry
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig(config_dict)
add_koji_map_in_workflow(workflow, hub_url=KOJI_HUB, root_url='',
ssl_certs_dir=plugin_args.get('koji_ssl_certs_dir'))
runner = PreBuildPluginsRunner(
workflow.builder.tasker,
workflow,
[{'name': KojiParentPlugin.key, 'args': plugin_args}]
)
result = runner.run()
if user_params:
return
base_img = ImageName.parse('base:latest')
if expect_result is True:
expected_result = {BASE_IMAGE_KOJI_BUILD: KOJI_BUILD,
PARENT_IMAGES_KOJI_BUILDS: {
base_img: KOJI_BUILD}}
if is_isolated is not None:
expected_result = deepcopy(expected_result)
expected_result[BASE_IMAGE_KOJI_BUILD]['extra']['image']['isolated'] = is_isolated
expected_result[PARENT_IMAGES_KOJI_BUILDS][base_img]['extra']['image']['isolated']\
= is_isolated
elif expect_result is False:
expected_result = None
else: # param provided the expected result
expected_result = expect_result
assert result[KojiParentPlugin.key] == expected_result
def test_append_from_user_params(workflow, flatpak, isolated, append):
workflow.user_params["flatpak"] = flatpak
workflow.user_params["isolated"] = isolated
add_koji_map_in_workflow(workflow, hub_url='', root_url='')
session = MockedClientSessionGeneral('')
flexmock(koji, ClientSession=session)
runner = PreBuildPluginsRunner(workflow, [])
plugin = runner.create_instance_from_plugin(BumpReleasePlugin, {})
assert plugin.append == append
def prepare(self,
tmpdir,
is_auto=False,
triggered_after_koji_task=None,
delegate_task=False,
delegated_priority=None):
workflow = flexmock()
setattr(workflow, 'builder', flexmock())
setattr(workflow, 'plugin_workspace', {})
setattr(workflow, 'reserved_build_id', None)
setattr(workflow, 'reserved_token ', None)
setattr(workflow, 'cancel_isolated_autorebuild', None)
setattr(workflow, 'triggered_after_koji_task', None)
setattr(workflow, 'source', MockSource(tmpdir))
setattr(workflow, 'prebuild_results',
{CheckAndSetRebuildPlugin.key: is_auto})
setattr(workflow, 'user_params', {})
df = tmpdir.join('Dockerfile')
df.write('FROM base\n')
setattr(workflow.builder, 'df_path', str(df))
kwargs = {
'tasker': None,
'workflow': workflow,
}
if triggered_after_koji_task:
kwargs['triggered_after_koji_task'] = triggered_after_koji_task
openshift_map = {
'url': '',
'insecure': False,
'auth': {
'enable': True
}
}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'openshift': openshift_map})
add_koji_map_in_workflow(workflow,
hub_url='',
root_url='',
reserve_build=False,
delegate_task=delegate_task,
delegated_priority=delegated_priority)
plugin = KojiDelegatePlugin(**kwargs)
return plugin
def prepare(workflow,
build_dir,
inherited_user='',
dockerfile=DEFAULT_DOCKERFILE,
scratch=False,
platforms=None,
include_koji_repo=False,
yum_proxy=None,
koji_ssl_certs=False,
root_url=ROOT,
yum_repourls=None):
if yum_repourls is None:
yum_repourls = {}
if not platforms:
platforms = ['x86_64']
if koji_ssl_certs:
build_dir.joinpath("cert").write_text("cert", "utf-8")
build_dir.joinpath("serverca").write_text("serverca", "utf-8")
workflow.user_params['scratch'] = scratch
workflow.data.prebuild_results[
PLUGIN_CHECK_AND_SET_PLATFORMS_KEY] = platforms
workflow.source = MockSource(build_dir)
inspect_data = {INSPECT_CONFIG: {'User': inherited_user}}
flexmock(workflow.imageutil).should_receive(
'base_image_inspect').and_return(inspect_data)
with open(workflow.source.dockerfile_path, 'w') as f:
f.write(dockerfile)
workflow.build_dir.init_build_dirs(platforms, workflow.source)
df = df_parser(str(build_dir))
df.content = dockerfile
workflow.data.dockerfile_images = DockerfileImages(df.parent_images)
if include_koji_repo:
session = MockedClientSession(hub='', opts=None)
workflow.koji_session = session
flexmock(koji, ClientSession=session, PathInfo=MockedPathInfo)
workflow.conf.conf = {'version': 1, 'yum_proxy': yum_proxy}
add_koji_map_in_workflow(
workflow,
hub_url='',
root_url=root_url,
ssl_certs_dir=str(build_dir) if koji_ssl_certs else None)
workflow.data.prebuild_results[PLUGIN_RESOLVE_COMPOSES_KEY] = {
'composes': [],
'include_koji_repo': include_koji_repo,
'yum_repourls': yum_repourls,
}
return workflow
def prepare(self,
workflow,
source_dir: Path,
labels=None,
certs=False,
append=False,
reserve_build=False,
add_timestamp=None,
fetch_source=False,
scratch=None):
if labels is None:
labels = {}
workflow.source = MockSource(str(source_dir), add_timestamp)
if scratch is not None:
workflow.user_params['scratch'] = scratch
if fetch_source:
workflow.data.prebuild_results[PLUGIN_FETCH_SOURCES_KEY] = {
'sources_for_nvr': KOJI_SOURCE_NVR
}
df = source_dir / 'Dockerfile'
lines: List[str] = ["FROM base"]
lines.extend(f"LABEL {key}={value}" for key, value in labels.items())
df.write_text('\n'.join(lines), "utf-8")
kwargs = {
'workflow': workflow,
}
if append:
kwargs['append'] = True
if certs:
source_dir.joinpath('cert').write_text('cert', 'utf-8')
source_dir.joinpath('serverca').write_text('serverca', 'utf-8')
add_koji_map_in_workflow(
workflow,
hub_url='',
root_url='',
reserve_build=reserve_build,
ssl_certs_dir=str(source_dir) if certs else None)
workflow.build_dir.init_build_dirs(["aarch", "x86_64"],
workflow.source)
plugin = BumpReleasePlugin(**kwargs)
return plugin
def test_fails_with_unknown_states(self, workflow):
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.spam.com',
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow,
smtp_host='smtp.bar.com', from_address='*****@*****.**',
send_on=['unknown_state', MS])
with pytest.raises(PluginFailedException) as e:
p.run()
assert str(e.value) == 'Unknown state(s) "unknown_state" for sendmail plugin'
def test_run_ok(self, tmpdir): # noqa
class TagConf(object):
unique_images = []
class WF(object):
autorebuild_canceled = False
build_canceled = False
prebuild_results = {CheckAndSetRebuildPlugin.key: True}
image = ImageName.parse('repo/name')
build_process_failed = True
tag_conf = TagConf()
exit_results = {}
plugin_workspace = {}
source = mock_source()
builder = mock_builder()
with open(os.path.join(str(tmpdir), 'Dockerfile'), 'wt') as df:
df.write(MOCK_DOCKERFILE)
setattr(builder, 'df_path', df.name)
receivers = ['*****@*****.**', '*****@*****.**']
workflow = WF()
mock_store_metadata_results(workflow)
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'smtp': smtp_map})
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(None, workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[AF])
(flexmock(p).should_receive('_should_send')
.with_args(True, False, False, False).and_return(True))
flexmock(p).should_receive('_get_receivers_list').and_return(receivers)
flexmock(p).should_receive('_fetch_log_files').and_return(None)
flexmock(p).should_receive('_send_mail').with_args(receivers,
str, str, None)
p.run()
def test_run_fails_to_obtain_receivers(self): # noqa
class TagConf(object):
unique_images = []
class WF(object):
autorebuild_canceled = False
build_canceled = False
prebuild_results = {CheckAndSetRebuildPlugin.key: True}
image = ImageName.parse('repo/name')
build_process_failed = True
tag_conf = TagConf()
exit_results = {}
plugin_workspace = {}
source = mock_source()
error_addresses = ['*****@*****.**']
workflow = WF()
mock_store_metadata_results(workflow)
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.bar.com',
'error_addresses': ['*****@*****.**'],
}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'smtp': smtp_map})
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(None, workflow,
from_address='*****@*****.**', smtp_host='smtp.spam.com',
send_on=[AF], error_addresses=error_addresses)
(flexmock(p).should_receive('_should_send')
.with_args(True, False, False, False).and_return(True))
flexmock(p).should_receive('_get_receivers_list').and_raise(RuntimeError())
flexmock(p).should_receive('_fetch_log_files').and_return(None)
flexmock(p).should_receive('_get_image_name_and_repos').and_return(('foobar',
['foo/bar:baz',
'foo/bar:spam']))
flexmock(p).should_receive('_send_mail').with_args(error_addresses, str, str, None)
p.run()
def test_should_send(self, success, manual_canceled, send_on, expected, workflow):
kwargs = {
'smtp_host': 'smtp.bar.com',
'from_address': '*****@*****.**',
'send_on': send_on,
}
workflow.data.postbuild_results[KojiImportPlugin.key] = MOCK_KOJI_BUILD_ID
smtp_map = {
'from_address': '*****@*****.**',
'host': 'smtp.spam.com',
}
rcm = {'version': 1, 'smtp': smtp_map, 'openshift': {'url': 'https://something.com'}}
workflow.conf = Configuration(raw_config=rcm)
add_koji_map_in_workflow(workflow, hub_url='/', root_url='',
ssl_certs_dir='/certs')
p = SendMailPlugin(workflow, **kwargs)
assert p._should_send(success, manual_canceled) == expected
