def test_create_missing_repo(self):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid],
fields=['id']).and_return([]).once().ordered())
(flexmock(mockpulp).should_receive('createRepo').with_args(
prefixed_pulp_repoid,
None,
registry_id=docker_repository,
prefix_with='redhat-').once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
plugin.run()
def test_pulp_repo_prefix(self,
get_prefix,
pulp_repo_prefix,
expected_prefix, reactor_config_map):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
env = 'pulp'
kwargs = {}
if pulp_repo_prefix:
kwargs['pulp_repo_prefix'] = pulp_repo_prefix
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
**kwargs)
mockpulp = MockPulp()
if get_prefix:
(flexmock(mockpulp)
.should_receive('getPrefix')
.with_args()
.and_return(expected_prefix))
else:
(flexmock(mockpulp)
.should_receive('getPrefix')
.with_args()
.and_raise(AttributeError))
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_delete_not_implemented(self, caplog, reactor_config_map): # noqa
"""
Should log an error (but not raise an exception) when
delete_from_registry is True.
"""
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
['redhat-prod-myrepository'], fields=['id']).and_return([{
'id':
'redhat-prod-myrepository'
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').and_return(([], [])))
flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': 'pulp'}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['prod/myrepository']),
pulp_registry_name='pulp',
docker_registry='http://registry.example.com',
delete_from_registry=True)
plugin.run()
errors = [
record.getMessage() for record in caplog.records()
if record.levelname == 'ERROR'
]
assert [message for message in errors if 'not implemented' in message]
def test_create_missing_repo(self, reactor_config_map): # noqa
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid],
fields=['id']).and_return([]).once().ordered())
(flexmock(mockpulp).should_receive('createRepo').with_args(
prefixed_pulp_repoid,
None,
registry_id=docker_repository,
prefix_with='redhat-').once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
plugin.run()
def test_insecure_registry(self, insecure_registry, ssl_validation):
docker_registry = "http://registry.example.com"
docker_repository = "prod/myrepository"
pulp_repoid = "prod-myrepository"
prefixed_pulp_repoid = "redhat-prod-myrepository"
env = "pulp"
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
insecure_registry=insecure_registry,
)
mockpulp = MockPulp()
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args([prefixed_pulp_repoid], fields=["id"])
.and_return([{"id": prefixed_pulp_repoid}])
.once()
.ordered()
)
sync_exp = flexmock(mockpulp).should_receive("syncRepo")
if ssl_validation is None:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
else:
sync_exp = sync_exp.with_args(
repo=prefixed_pulp_repoid, feed=docker_registry, ssl_validation=ssl_validation
)
(sync_exp.and_return(([], [])).once().ordered())
(flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))
plugin.run()
def test_dockercfg_missing_or_invalid(self, tmpdir, content, reactor_config_map):
env = 'pulp'
if content is not None:
registry_secret = os.path.join(str(tmpdir), '.dockercfg')
with open(registry_secret, 'w') as fp:
fp.write(content)
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['repo']),
pulp_registry_name=env,
docker_registry='http://registry.example.com',
registry_secret_path=str(tmpdir))
mockpulp = MockPulp()
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
with pytest.raises(RuntimeError):
plugin.run()
def test_store_registry(self, already_exists):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
env = 'pulp'
workflow = self.workflow([docker_repository])
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
object,
'prod-myrepository', # pulp repository name
config_file=object).and_return([{
'id': 'prefix-prod-myrepository'
}]) # repo id
.once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
['prefix-prod-myrepository'], # repo id
wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
if already_exists:
workflow.push_conf.add_pulp_registry(env, mockpulp.registry)
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
pulp_registry_name=env,
docker_registry=docker_registry)
num_registries = len(workflow.push_conf.pulp_registries)
assert num_registries == (1 if already_exists else 0)
plugin.run()
assert len(workflow.push_conf.pulp_registries) == 1
def test_delete_not_implemented(self, caplog):
"""
Should log an error (but not raise an exception) when
delete_from_registry is True.
"""
mockpulp = MockPulp()
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args(["redhat-prod-myrepository"], fields=["id"])
.and_return([{"id": "redhat-prod-myrepository"}])
.once()
.ordered()
)
(flexmock(mockpulp).should_receive("syncRepo").and_return(([], [])))
flexmock(dockpulp).should_receive("Pulp").and_return(mockpulp)
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow(["prod/myrepository"]),
pulp_registry_name="pulp",
docker_registry="http://registry.example.com",
delete_from_registry=True,
)
plugin.run()
errors = [record.getMessage() for record in caplog.records() if record.levelname == "ERROR"]
assert [message for message in errors if "not implemented" in message]
def test_store_registry(self, already_exists):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
workflow = self.workflow([docker_repository])
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
if already_exists:
workflow.push_conf.add_pulp_registry(env, mockpulp.registry)
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
pulp_registry_name=env,
docker_registry=docker_registry)
num_registries = len(workflow.push_conf.pulp_registries)
assert num_registries == (1 if already_exists else 0)
plugin.run()
assert len(workflow.push_conf.pulp_registries) == 1
def test_dockercfg_missing_or_invalid(self, tmpdir, content,
reactor_config_map):
env = 'pulp'
if content is not None:
registry_secret = os.path.join(str(tmpdir), '.dockercfg')
with open(registry_secret, 'w') as fp:
fp.write(content)
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['repo']),
pulp_registry_name=env,
docker_registry='http://registry.example.com',
registry_secret_path=str(tmpdir))
mockpulp = MockPulp()
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
with pytest.raises(RuntimeError):
plugin.run()
def test_insecure_registry(self, insecure_registry, ssl_validation):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
insecure_registry=insecure_registry)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
sync_exp = flexmock(mockpulp).should_receive('syncRepo')
if ssl_validation is None:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
else:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry,
ssl_validation=ssl_validation)
(sync_exp.and_return(([], [])).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
plugin.run()
def test_delete_not_implemented(self, caplog):
"""
Should log an error (but not raise an exception) when
delete_from_registry is True.
"""
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
['redhat-prod-myrepository'], fields=['id']).and_return([{
'id':
'redhat-prod-myrepository'
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').and_return(([], [])))
flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['prod/myrepository']),
pulp_registry_name='pulp',
docker_registry='http://registry.example.com',
delete_from_registry=True)
plugin.run()
errors = [
record.getMessage() for record in caplog.records()
if record.levelname == 'ERROR'
]
assert [message for message in errors if 'not implemented' in message]
def test_auth_none(self):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
object,
'prod-myrepository', # pulp repository name
config_file=object).and_return([{
'id': 'prefix-prod-myrepository'
}]) # repo id
.once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
['prefix-prod-myrepository'], # repo id
wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
plugin.run()
def test_delete_not_implemented(self, caplog):
"""
Should log an error (but not raise an exception) when
delete_from_registry is True.
"""
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args(['redhat-prod-myrepository'], fields=['id'])
.and_return([{'id': 'redhat-prod-myrepository'}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.and_return(([], [])))
flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['prod/myrepository']),
pulp_registry_name='pulp',
docker_registry='http://registry.example.com',
delete_from_registry=True)
plugin.run()
errors = [record.getMessage() for record in caplog.records()
if record.levelname == 'ERROR']
assert [message for message in errors
if 'not implemented' in message]
def test_workspace_updated(self, reactor_config_map): # noqa
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
workflow = self.workflow([docker_repository], mockpulp.registry)
workflow.postbuild_plugins_conf.append(
{
'name': PulpSyncPlugin.key,
},
)
kwargs = {
'pulp_registry_name': env,
'docker_registry': docker_registry,
}
if reactor_config_map:
workflow.plugin_workspace = {}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1,
'pulp': {'name': env,
'auth': {'user': '', 'password': ''}}})
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
**kwargs)
plugin.run()
manifests = get_manifests_in_pulp_repository(workflow)
assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
def test_store_registry(self, already_exists, reactor_config_map):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
workflow = self.workflow([docker_repository])
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.never())
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
if already_exists:
workflow.push_conf.add_pulp_registry(env, mockpulp.registry,
server_side_sync=False)
if reactor_config_map:
workflow.plugin_workspace = {}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1,
'pulp': {'name': env,
'auth': {'user': '', 'password': ''}}})
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
pulp_registry_name=env,
docker_registry=docker_registry)
num_registries = len(workflow.push_conf.pulp_registries)
assert num_registries == (1 if already_exists else 0)
plugin.run()
assert len(workflow.push_conf.pulp_registries) == 1
def test_pulp_auth(self, tmpdir, cer_exists, key_exists,
reactor_config_map):
pulp_secret_path = str(tmpdir)
cer = pulp_secret_path + '/pulp.cer'
key = pulp_secret_path + '/pulp.key'
if cer_exists:
open(cer, 'w').close()
if key_exists:
open(key, 'w').close()
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
pulp_secret_path=pulp_secret_path)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
if cer_exists and key_exists:
(flexmock(mockpulp).should_receive('set_certs').with_args(
cer, key).once().ordered())
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
else:
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('syncRepo').never())
(flexmock(mockpulp).should_receive('crane').never())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
if cer_exists and key_exists:
plugin.run()
else:
with pytest.raises(RuntimeError):
plugin.run()
def test_pulp_auth(self, tmpdir, cer_exists, key_exists):
pulp_secret_path = str(tmpdir)
cer = pulp_secret_path + "/pulp.cer"
key = pulp_secret_path + "/pulp.key"
if cer_exists:
open(cer, "w").close()
if key_exists:
open(key, "w").close()
docker_registry = "http://registry.example.com"
docker_repository = "prod/myrepository"
pulp_repoid = "prod-myrepository"
prefixed_pulp_repoid = "redhat-prod-myrepository"
env = "pulp"
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
pulp_secret_path=pulp_secret_path,
)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive("login").never())
if cer_exists and key_exists:
(flexmock(mockpulp).should_receive("set_certs").with_args(cer, key).once().ordered())
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args([prefixed_pulp_repoid], fields=["id"])
.and_return([{"id": prefixed_pulp_repoid}])
.once()
.ordered()
)
(
flexmock(mockpulp)
.should_receive("syncRepo")
.with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
.and_return(([], []))
.once()
.ordered()
)
(flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
else:
(flexmock(mockpulp).should_receive("set_certs").never())
(flexmock(mockpulp).should_receive("syncRepo").never())
(flexmock(mockpulp).should_receive("crane").never())
(flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))
if cer_exists and key_exists:
plugin.run()
else:
with pytest.raises(RuntimeError):
plugin.run()
def test_auth_certs(self, tmpdir, cer_exists, key_exists, source_secret,
monkeypatch):
pulp_secret_path = str(tmpdir)
cer = pulp_secret_path + '/pulp.cer'
key = pulp_secret_path + '/pulp.key'
if cer_exists:
open(cer, 'w').close()
if key_exists:
open(key, 'w').close()
if source_secret:
monkeypatch.setenv('SOURCE_SECRET_PATH', pulp_secret_path)
pulp_secret_path = None
else:
monkeypatch.delenv('SOURCE_SECRET_PATH', raising=False)
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
pulp_secret_path=pulp_secret_path)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
if cer_exists and key_exists:
(flexmock(mockpulp).should_receive('set_certs').with_args(
cer, key).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
object,
'prod-myrepository', # pulp repository name
config_file=object).and_return([{
'id':
'prefix-prod-myrepository'
}]) # repo id
.once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
['prefix-prod-myrepository'], # repo id
wait=True).once().ordered())
else:
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('syncRepo').never())
(flexmock(mockpulp).should_receive('crane').never())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
if cer_exists and key_exists:
plugin.run()
else:
with pytest.raises(RuntimeError):
plugin.run()
def test_pulp_repo_prefix(self,
get_prefix,
pulp_repo_prefix,
expected_prefix):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
pulp_repoid = 'prod-myrepository'
prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
env = 'pulp'
kwargs = {}
if pulp_repo_prefix:
kwargs['pulp_repo_prefix'] = pulp_repo_prefix
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
**kwargs)
mockpulp = MockPulp()
if get_prefix:
(flexmock(mockpulp)
.should_receive('getPrefix')
.with_args()
.and_return(expected_prefix))
else:
(flexmock(mockpulp)
.should_receive('getPrefix')
.with_args()
.and_raise(AttributeError))
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_dockercfg(self, tmpdir, scheme, reactor_config_map):
docker_registry = '{}://registry.example.com'.format(scheme)
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
user = '******'
pw = 'pass'
env = 'pulp'
registry_secret = os.path.join(str(tmpdir), '.dockercfg')
dockercfg = {
'registry.example.com': {
'username': user,
'password': pw,
'email': '*****@*****.**',
},
}
with open(registry_secret, 'w') as fp:
json.dump(dockercfg, fp)
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
registry_secret_path=str(tmpdir))
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry,
basic_auth_username=user,
basic_auth_password=pw)
.and_return(([], []))
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_publish(self, publish, has_pulp_push, should_publish, caplog):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
if should_publish:
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
else:
(flexmock(mockpulp).should_receive('crane').never())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
workflow = self.workflow([docker_repository], mockpulp.registry)
workflow.postbuild_plugins_conf.append({
'name': PulpSyncPlugin.key,
}, )
if has_pulp_push:
workflow.postbuild_plugins_conf.append(
{
'name': PLUGIN_PULP_PUSH_KEY,
}, )
kwargs = {
'pulp_registry_name': env,
'docker_registry': docker_registry,
}
if publish is not None:
kwargs['publish'] = publish
plugin = PulpSyncPlugin(tasker=None, workflow=workflow, **kwargs)
plugin.run()
log_messages = [l.getMessage() for l in caplog.records()]
for image in workflow.tag_conf.images:
expected_log = 'image available at %s' % image.to_str()
if should_publish:
assert expected_log in log_messages
else:
assert expected_log not in log_messages
def test_pulp_repo_prefix(self,
get_prefix,
pulp_repo_prefix,
expected_prefix):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
env = 'pulp'
kwargs = {}
if pulp_repo_prefix:
kwargs['pulp_repo_prefix'] = pulp_repo_prefix
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
**kwargs)
mockpulp = MockPulp()
if get_prefix:
(flexmock(mockpulp)
.should_receive('getPrefix')
.with_args()
.and_return(expected_prefix))
else:
(flexmock(mockpulp)
.should_receive('getPrefix')
.with_args()
.and_raise(AttributeError))
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_workspace_updated(self):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
workflow = self.workflow([docker_repository], mockpulp.registry)
workflow.postbuild_plugins_conf.append(
{
'name': PulpSyncPlugin.key,
},
)
kwargs = {
'pulp_registry_name': env,
'docker_registry': docker_registry,
}
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
**kwargs)
plugin.run()
manifests = get_manifests_in_pulp_repository(workflow)
assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
def test_store_registry(self, already_exists):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
workflow = self.workflow([docker_repository])
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.never())
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
if already_exists:
workflow.push_conf.add_pulp_registry(env, mockpulp.registry,
server_side_sync=False)
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
pulp_registry_name=env,
docker_registry=docker_registry)
num_registries = len(workflow.push_conf.pulp_registries)
assert num_registries == (1 if already_exists else 0)
plugin.run()
assert len(workflow.push_conf.pulp_registries) == 1
def test_dockercfg(self, tmpdir, scheme):
docker_registry = '{}://registry.example.com'.format(scheme)
docker_repository = 'prod/myrepository'
pulp_repoid = 'prod-myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
user = '******'
pw = 'pass'
env = 'pulp'
registry_secret = os.path.join(str(tmpdir), '.dockercfg')
dockercfg = {
'registry.example.com': {
'username': user,
'password': pw,
'email': '*****@*****.**',
},
}
with open(registry_secret, 'w') as fp:
json.dump(dockercfg, fp)
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
registry_secret_path=str(tmpdir))
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry,
basic_auth_username=user,
basic_auth_password=pw)
.and_return(([], []))
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_create_missing_repo(self, reactor_config_map): # noqa
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry)
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('createRepo')
.with_args(prefixed_pulp_repoid, None,
registry_id=docker_repository,
prefix_with='redhat-')
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_store_registry(self, already_exists, reactor_config_map):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
workflow = self.workflow([docker_repository])
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
if already_exists:
workflow.push_conf.add_pulp_registry(env,
mockpulp.registry,
server_side_sync=False)
if reactor_config_map:
workflow.plugin_workspace = {}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1,
'pulp': {'name': env,
'auth': {'user': '', 'password': ''}}})
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
pulp_registry_name=env,
docker_registry=docker_registry)
num_registries = len(workflow.push_conf.pulp_registries)
assert num_registries == (1 if already_exists else 0)
plugin.run()
assert len(workflow.push_conf.pulp_registries) == 1
def test_dockercfg(self, tmpdir, scheme):
docker_registry = "{}://registry.example.com".format(scheme)
docker_repository = "prod/myrepository"
pulp_repoid = "prod-myrepository"
prefixed_pulp_repoid = "redhat-prod-myrepository"
user = "******"
pw = "pass"
env = "pulp"
registry_secret = os.path.join(str(tmpdir), ".dockercfg")
dockercfg = {"registry.example.com": {"username": user, "password": pw, "email": "*****@*****.**"}}
with open(registry_secret, "w") as fp:
json.dump(dockercfg, fp)
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
registry_secret_path=str(tmpdir),
)
mockpulp = MockPulp()
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args([prefixed_pulp_repoid], fields=["id"])
.and_return([{"id": prefixed_pulp_repoid}])
.once()
.ordered()
)
(
flexmock(mockpulp)
.should_receive("syncRepo")
.with_args(
repo=prefixed_pulp_repoid, feed=docker_registry, basic_auth_username=user, basic_auth_password=pw
)
.and_return(([], []))
.once()
.ordered()
)
(flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))
plugin.run()
def test_dockpulp_loglevel(self, fail, caplog, reactor_config_map):
loglevel = 3
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args(['redhat-prod-myrepository'], fields=['id'])
.and_return([{'id': 'redhat-prod-myrepository'}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.and_return(([], [])))
flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
logger = flexmock()
expectation = (logger
.should_receive('setLevel')
.with_args(loglevel)
.once())
if fail:
expectation.and_raise(ValueError)
flexmock(PulpLogWrapper).should_receive('get_pulp_logger').and_return(logger).once()
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': 'pulp'}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['prod/myrepository']),
pulp_registry_name='pulp',
docker_registry='http://registry.example.com',
dockpulp_loglevel=loglevel)
plugin.run()
errors = [record.getMessage() for record in caplog.records
if record.levelname == 'ERROR']
if fail:
assert len(errors) >= 1
else:
assert not errors
def test_insecure_registry(self, insecure_registry, ssl_validation, reactor_config_map):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
insecure_registry=insecure_registry)
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
sync_exp = flexmock(mockpulp).should_receive('syncRepo')
if ssl_validation is None:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
else:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry,
ssl_validation=ssl_validation)
(sync_exp
.and_return(([], []))
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_dockercfg_registry_not_present(self, tmpdir):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
registry_secret = os.path.join(str(tmpdir), '.dockercfg')
dockercfg = {
'other-registry.example.com': {
'username': '******',
'password': '******',
'email': '*****@*****.**',
},
}
with open(registry_secret, 'w') as fp:
json.dump(dockercfg, fp)
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
registry_secret_path=str(tmpdir))
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_workspace_updated(self, reactor_config_map): # noqa
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
workflow = self.workflow([docker_repository], mockpulp.registry)
workflow.postbuild_plugins_conf.append({
'name': PulpSyncPlugin.key,
}, )
kwargs = {
'pulp_registry_name': env,
'docker_registry': docker_registry,
}
if reactor_config_map:
workflow.plugin_workspace = {}
workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1,
'pulp': {'name': env,
'auth': {'user': '', 'password': ''}}})
plugin = PulpSyncPlugin(tasker=None, workflow=workflow, **kwargs)
plugin.run()
manifests = get_manifests_in_pulp_repository(workflow)
assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
def test_store_registry(self, already_exists):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
env = 'pulp'
workflow = self.workflow([docker_repository])
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.never())
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(object,
'prod-myrepository', # pulp repository name
config_file=object)
.and_return([{'id': 'prefix-prod-myrepository'}]) # repo id
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args(['prefix-prod-myrepository'], # repo id
wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
if already_exists:
workflow.push_conf.add_pulp_registry(env, mockpulp.registry)
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
pulp_registry_name=env,
docker_registry=docker_registry)
num_registries = len(workflow.push_conf.pulp_registries)
assert num_registries == (1 if already_exists else 0)
plugin.run()
assert len(workflow.push_conf.pulp_registries) == 1
def test_pulp_repo_prefix(self, get_prefix, pulp_repo_prefix, expected_prefix):
docker_registry = "http://registry.example.com"
docker_repository = "prod/myrepository"
pulp_repoid = "prod-myrepository"
prefixed_pulp_repoid = "{}prod-myrepository".format(expected_prefix)
env = "pulp"
kwargs = {}
if pulp_repo_prefix:
kwargs["pulp_repo_prefix"] = pulp_repo_prefix
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
**kwargs
)
mockpulp = MockPulp()
if get_prefix:
(flexmock(mockpulp).should_receive("getPrefix").with_args().and_return(expected_prefix))
else:
(flexmock(mockpulp).should_receive("getPrefix").with_args().and_raise(AttributeError))
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args([prefixed_pulp_repoid], fields=["id"])
.and_return([{"id": prefixed_pulp_repoid}])
.once()
.ordered()
)
(
flexmock(mockpulp)
.should_receive("syncRepo")
.with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
.and_return(([], []))
.once()
.ordered()
)
(flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))
plugin.run()
def test_pulp_repo_prefix(self, get_prefix, pulp_repo_prefix,
expected_prefix, reactor_config_map):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = '{}prod-myrepository'.format(expected_prefix)
env = 'pulp'
kwargs = {}
if pulp_repo_prefix:
kwargs['pulp_repo_prefix'] = pulp_repo_prefix
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
**kwargs)
mockpulp = MockPulp()
if get_prefix:
(flexmock(mockpulp).should_receive(
'getPrefix').with_args().and_return(expected_prefix))
else:
(flexmock(mockpulp).should_receive(
'getPrefix').with_args().and_raise(AttributeError))
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
plugin.run()
def test_dockercfg_registry_not_present(self, tmpdir,
reactor_config_map): # noqa
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
registry_secret = os.path.join(str(tmpdir), '.dockercfg')
dockercfg = {
'other-registry.example.com': {
'username': '******',
'password': '******',
'email': '*****@*****.**',
},
}
with open(registry_secret, 'w') as fp:
json.dump(dockercfg, fp)
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
registry_secret_path=str(tmpdir))
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
plugin.run()
def test_print_availability_info(self, has_pulp_push, caplog):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
pulp_repoid = 'prod-myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('login').never())
(flexmock(mockpulp).should_receive('set_certs').never())
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
workflow = self.workflow([docker_repository], mockpulp.registry)
workflow.postbuild_plugins_conf.append({'name': PulpSyncPlugin.key})
if has_pulp_push:
# PulpPushPlugin.key is not imported here to avoid circular import
workflow.postbuild_plugins_conf.append({'name': 'pulp_push'})
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
pulp_registry_name=env,
docker_registry=docker_registry)
plugin.run()
log_messages = [l.getMessage() for l in caplog.records()]
for image in workflow.tag_conf.images:
expected_log = 'image available at %s' % image.to_str()
if has_pulp_push:
assert expected_log not in log_messages
else:
assert expected_log in log_messages
def test_dockpulp_loglevel(self, fail, caplog, reactor_config_map):
loglevel = 3
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
['redhat-prod-myrepository'], fields=['id']).and_return([{
'id':
'redhat-prod-myrepository'
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').and_return(([], [])))
flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
logger = flexmock()
expectation = (
logger.should_receive('setLevel').with_args(loglevel).once())
if fail:
expectation.and_raise(ValueError)
flexmock(PulpLogWrapper).should_receive('get_pulp_logger').and_return(
logger).once()
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': 'pulp'}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['prod/myrepository']),
pulp_registry_name='pulp',
docker_registry='http://registry.example.com',
dockpulp_loglevel=loglevel)
plugin.run()
errors = [
record.getMessage() for record in caplog.records()
if record.levelname == 'ERROR'
]
if fail:
assert len(errors) >= 1
else:
assert not errors
def test_auth_password(self):
username = '******'
password = '******'
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
username=username,
password=password)
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.with_args(username, password)
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(object,
'prod-myrepository', # pulp repository name
config_file=object)
.and_return([{'id': 'prefix-prod-myrepository'}]) # repo id
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args(['prefix-prod-myrepository'], # repo id
wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_dockpulp_loglevel(self, fail, caplog):
loglevel = 3
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args(['redhat-prod-myrepository'], fields=['id'])
.and_return([{'id': 'redhat-prod-myrepository'}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.and_return(([], [])))
flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
logger = flexmock()
expectation = (logger
.should_receive('setLevel')
.with_args(loglevel)
.once())
if fail:
expectation.and_raise(ValueError)
(flexmock(dockpulp)
.should_receive('setup_logger')
.and_return(logger)
.once())
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['prod/myrepository']),
pulp_registry_name='pulp',
docker_registry='http://registry.example.com',
dockpulp_loglevel=loglevel)
plugin.run()
errors = [record.getMessage() for record in caplog.records()
if record.levelname == 'ERROR']
if fail:
assert len(errors) >= 1
else:
assert not errors
def test_auth_none(self):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry)
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.never())
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_dockpulp_loglevel(self, fail, caplog):
loglevel = 3
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args(['redhat-prod-myrepository'], fields=['id'])
.and_return([{'id': 'redhat-prod-myrepository'}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.and_return(([], [])))
flexmock(dockpulp).should_receive('Pulp').and_return(mockpulp)
logger = flexmock()
expectation = (logger
.should_receive('setLevel')
.with_args(loglevel)
.once())
if fail:
expectation.and_raise(ValueError)
(flexmock(dockpulp)
.should_receive('setup_logger')
.and_return(logger)
.once())
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['prod/myrepository']),
pulp_registry_name='pulp',
docker_registry='http://registry.example.com',
dockpulp_loglevel=loglevel)
plugin.run()
errors = [record.getMessage() for record in caplog.records()
if record.levelname == 'ERROR']
if fail:
assert len(errors) >= 1
else:
assert not errors
def test_dockercfg_missing_or_invalid(self, tmpdir, content):
env = 'pulp'
if content is not None:
registry_secret = os.path.join(str(tmpdir), '.dockercfg')
with open(registry_secret, 'w') as fp:
fp.write(content)
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow(['repo']),
pulp_registry_name=env,
docker_registry='http://registry.example.com',
registry_secret_path=str(tmpdir))
mockpulp = MockPulp()
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
with pytest.raises(RuntimeError):
plugin.run()
def test_create_missing_repo(self):
docker_registry = "http://registry.example.com"
docker_repository = "prod/myrepository"
pulp_repoid = "prod-myrepository"
prefixed_pulp_repoid = "redhat-prod-myrepository"
env = "pulp"
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
)
mockpulp = MockPulp()
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args([prefixed_pulp_repoid], fields=["id"])
.and_return([])
.once()
.ordered()
)
(
flexmock(mockpulp)
.should_receive("createRepo")
.with_args(prefixed_pulp_repoid, None, registry_id=docker_repository, prefix_with="redhat-")
.once()
.ordered()
)
(
flexmock(mockpulp)
.should_receive("syncRepo")
.with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
.and_return(([], []))
.once()
.ordered()
)
(flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))
plugin.run()
def test_dockercfg_missing_or_invalid(self, tmpdir, content):
env = "pulp"
if content is not None:
registry_secret = os.path.join(str(tmpdir), ".dockercfg")
with open(registry_secret, "w") as fp:
fp.write(content)
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow(["repo"]),
pulp_registry_name=env,
docker_registry="http://registry.example.com",
registry_secret_path=str(tmpdir),
)
mockpulp = MockPulp()
(flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))
with pytest.raises(RuntimeError):
plugin.run()
def test_store_registry(self, already_exists):
docker_registry = "http://registry.example.com"
docker_repository = "prod/myrepository"
pulp_repoid = "prod-myrepository"
prefixed_pulp_repoid = "redhat-prod-myrepository"
env = "pulp"
workflow = self.workflow([docker_repository])
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive("login").never())
(flexmock(mockpulp).should_receive("set_certs").never())
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args([prefixed_pulp_repoid], fields=["id"])
.and_return([{"id": prefixed_pulp_repoid}])
.once()
.ordered()
)
(
flexmock(mockpulp)
.should_receive("syncRepo")
.with_args(repo=prefixed_pulp_repoid, feed=docker_registry)
.and_return(([], []))
.once()
.ordered()
)
(flexmock(mockpulp).should_receive("crane").with_args([prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive("Pulp").with_args(env=env).and_return(mockpulp))
if already_exists:
workflow.push_conf.add_pulp_registry(env, mockpulp.registry)
plugin = PulpSyncPlugin(tasker=None, workflow=workflow, pulp_registry_name=env, docker_registry=docker_registry)
num_registries = len(workflow.push_conf.pulp_registries)
assert num_registries == (1 if already_exists else 0)
plugin.run()
assert len(workflow.push_conf.pulp_registries) == 1
def test_insecure_registry(self, insecure_registry, ssl_validation,
reactor_config_map):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
if reactor_config_map:
self.workflow.plugin_workspace = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key] = {}
self.workflow.plugin_workspace[ReactorConfigPlugin.key][WORKSPACE_CONF_KEY] =\
ReactorConfig({'version': 1, 'pulp': {'name': env}})
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
insecure_registry=insecure_registry)
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
sync_exp = flexmock(mockpulp).should_receive('syncRepo')
if ssl_validation is None:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
else:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry,
ssl_validation=ssl_validation)
(sync_exp.and_return(([], [])).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
plugin.run()
def test_workspace_updated(self):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
mockpulp = MockPulp()
(flexmock(mockpulp).should_receive('getRepos').with_args(
[prefixed_pulp_repoid], fields=['id']).and_return([{
'id':
prefixed_pulp_repoid
}]).once().ordered())
(flexmock(mockpulp).should_receive('syncRepo').with_args(
repo=prefixed_pulp_repoid, feed=docker_registry).and_return(
([], [])).once().ordered())
(flexmock(mockpulp).should_receive('crane').with_args(
[prefixed_pulp_repoid], wait=True).once().ordered())
(flexmock(dockpulp).should_receive('Pulp').with_args(
env=env).and_return(mockpulp))
workflow = self.workflow([docker_repository], mockpulp.registry)
workflow.postbuild_plugins_conf.append({
'name': PulpSyncPlugin.key,
}, )
kwargs = {
'pulp_registry_name': env,
'docker_registry': docker_registry,
}
plugin = PulpSyncPlugin(tasker=None, workflow=workflow, **kwargs)
plugin.run()
manifests = get_manifests_in_pulp_repository(workflow)
assert manifests == ['sha256:{}'.format(prefixed_pulp_repoid)]
def test_dockpulp_loglevel(self, fail, caplog):
loglevel = 3
mockpulp = MockPulp()
(
flexmock(mockpulp)
.should_receive("getRepos")
.with_args(["redhat-prod-myrepository"], fields=["id"])
.and_return([{"id": "redhat-prod-myrepository"}])
.once()
.ordered()
)
(flexmock(mockpulp).should_receive("syncRepo").and_return(([], [])))
flexmock(dockpulp).should_receive("Pulp").and_return(mockpulp)
logger = flexmock()
expectation = logger.should_receive("setLevel").with_args(loglevel).once()
if fail:
expectation.and_raise(ValueError)
(flexmock(dockpulp).should_receive("setup_logger").and_return(logger).once())
plugin = PulpSyncPlugin(
tasker=None,
workflow=self.workflow(["prod/myrepository"]),
pulp_registry_name="pulp",
docker_registry="http://registry.example.com",
dockpulp_loglevel=loglevel,
)
plugin.run()
errors = [record.getMessage() for record in caplog.records() if record.levelname == "ERROR"]
if fail:
assert len(errors) >= 1
else:
assert not errors
def test_insecure_registry(self, insecure_registry, ssl_validation):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
insecure_registry=insecure_registry)
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
sync_exp = flexmock(mockpulp).should_receive('syncRepo')
if ssl_validation is None:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
else:
sync_exp = sync_exp.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry,
ssl_validation=ssl_validation)
(sync_exp
.and_return(([], []))
.once()
.ordered())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
plugin.run()
def test_pulp_auth(self, tmpdir, cer_exists, key_exists):
pulp_secret_path = str(tmpdir)
cer = pulp_secret_path + '/pulp.cer'
key = pulp_secret_path + '/pulp.key'
if cer_exists:
open(cer, 'w').close()
if key_exists:
open(key, 'w').close()
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
pulp_secret_path=pulp_secret_path)
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.never())
if cer_exists and key_exists:
(flexmock(mockpulp)
.should_receive('set_certs')
.with_args(cer, key)
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
else:
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('syncRepo')
.never())
(flexmock(mockpulp)
.should_receive('crane')
.never())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
if cer_exists and key_exists:
plugin.run()
else:
with pytest.raises(RuntimeError):
plugin.run()
def test_publish(self, publish, has_pulp_push, should_publish, caplog):
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
prefixed_pulp_repoid = 'redhat-prod-myrepository'
env = 'pulp'
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.never())
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('getRepos')
.with_args([prefixed_pulp_repoid], fields=['id'])
.and_return([{'id': prefixed_pulp_repoid}])
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(repo=prefixed_pulp_repoid,
feed=docker_registry)
.and_return(([], []))
.once()
.ordered())
if should_publish:
(flexmock(mockpulp)
.should_receive('crane')
.with_args([prefixed_pulp_repoid], wait=True)
.once()
.ordered())
else:
(flexmock(mockpulp)
.should_receive('crane')
.never())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
workflow = self.workflow([docker_repository], mockpulp.registry)
workflow.postbuild_plugins_conf.append(
{
'name': PulpSyncPlugin.key,
},
)
if has_pulp_push:
workflow.postbuild_plugins_conf.append(
{
'name': PLUGIN_PULP_PUSH_KEY,
},
)
kwargs = {
'pulp_registry_name': env,
'docker_registry': docker_registry,
}
if publish is not None:
kwargs['publish'] = publish
plugin = PulpSyncPlugin(tasker=None,
workflow=workflow,
**kwargs)
plugin.run()
log_messages = [l.getMessage() for l in caplog.records()]
for image in workflow.tag_conf.images:
expected_log = 'image available at %s' % image.to_str()
if should_publish:
assert expected_log in log_messages
else:
assert expected_log not in log_messages
def test_auth_certs(self, tmpdir, cer_exists, key_exists, source_secret, monkeypatch):
pulp_secret_path = str(tmpdir)
cer = pulp_secret_path + '/pulp.cer'
key = pulp_secret_path + '/pulp.key'
if cer_exists:
open(cer, 'w').close()
if key_exists:
open(key, 'w').close()
if source_secret:
monkeypatch.setenv('SOURCE_SECRET_PATH', pulp_secret_path)
pulp_secret_path = None
else:
monkeypatch.delenv('SOURCE_SECRET_PATH', raising=False)
docker_registry = 'http://registry.example.com'
docker_repository = 'prod/myrepository'
env = 'pulp'
plugin = PulpSyncPlugin(tasker=None,
workflow=self.workflow([docker_repository]),
pulp_registry_name=env,
docker_registry=docker_registry,
pulp_secret_path=pulp_secret_path)
mockpulp = MockPulp()
(flexmock(mockpulp)
.should_receive('login')
.never())
if cer_exists and key_exists:
(flexmock(mockpulp)
.should_receive('set_certs')
.with_args(cer, key)
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('syncRepo')
.with_args(object,
'prod-myrepository', # pulp repository name
config_file=object)
.and_return([{'id': 'prefix-prod-myrepository'}]) # repo id
.once()
.ordered())
(flexmock(mockpulp)
.should_receive('crane')
.with_args(['prefix-prod-myrepository'], # repo id
wait=True)
.once()
.ordered())
else:
(flexmock(mockpulp)
.should_receive('set_certs')
.never())
(flexmock(mockpulp)
.should_receive('syncRepo')
.never())
(flexmock(mockpulp)
.should_receive('crane')
.never())
(flexmock(dockpulp)
.should_receive('Pulp')
.with_args(env=env)
.and_return(mockpulp))
if cer_exists and key_exists:
plugin.run()
else:
with pytest.raises(RuntimeError):
plugin.run()