def test_translate_obs_uri_inside_buildservice(
self, mock_buildservice, mock_warn
):
mock_buildservice.return_value = True
uri = Uri('obs://openSUSE:Leap:42.2/standard', 'rpm-md')
uri.runtime_config = self.runtime_config
assert uri.translate(False) == \
'obs_server/openSUSE:/Leap:/42.2/standard'
assert mock_warn.called
def test_translate_obs_uri_inside_buildservice(
self, mock_buildservice
):
mock_buildservice.return_value = True
uri = Uri('obs://openSUSE:Leap:42.2/standard', 'rpm-md')
uri.runtime_config = self.runtime_config
with self._caplog.at_level(logging.WARNING):
assert uri.translate(False) == \
'obs_server/openSUSE:/Leap:/42.2/standard'
def test_is_public(self, mock_request):
# unknown uri schema is considered not public
uri = Uri('xxx', 'rpm-md')
assert uri.is_public() is False
# https is public
uri = Uri('https://example.com', 'rpm-md')
assert uri.is_public() is True
# obs is private with obs_public set to false in config
uri = Uri('obs://openSUSE:Leap:42.2/standard', 'yast2')
self.runtime_config.is_obs_public = mock.Mock(return_value=False)
uri.runtime_config = self.runtime_config
assert uri.is_public() is False
# unknown uri type considered not public
uri = Uri('httpx://example.com', 'rpm-md')
assert uri.is_public() is False
def test_translate_buildservice_obsrepositories_container_path(
self, mock_buildservice
):
mock_buildservice.return_value = True
uri = Uri('obsrepositories:/container#latest', 'container')
assert uri.translate() == ''.join(
[
'/usr/src/packages/SOURCES/containers/',
'_obsrepositories/container#latest'
]
)
def setup(self, mock_mkdtemp, mock_path):
mock_path.return_value = True
tmpdirs = ['kiwi_unpack_dir', 'kiwi_layout_dir']
def call_mkdtemp(prefix):
return tmpdirs.pop()
mock_mkdtemp.side_effect = call_mkdtemp
self.oci_import = RootImportOCI('root_dir',
Uri('file:///image.tar.xz#tag'))
assert self.oci_import.image_file == '/image.tar.xz'
def test_destructor(self, mock_wipe, mock_mkdtemp, mock_manager):
mock_mkdtemp.return_value = 'tmpdir'
manager = mock.Mock()
manager.mountpoint = mock_mkdtemp.return_value
manager.is_mounted = mock.Mock(return_value=True)
mock_manager.return_value = manager
uri = Uri('iso:///image/CDs/openSUSE-13.2-DVD-x86_64.iso', 'yast2')
uri.translate()
uri.__del__()
manager.umount.assert_called_once_with()
mock_wipe.assert_called_once_with(manager.mountpoint)
def _setup_solver(self):
solver = Sat()
for xml_repo in self.xml_state.get_repository_sections_used_for_build(
):
repo_source = xml_repo.get_source().get_path()
repo_user = xml_repo.get_username()
repo_secret = xml_repo.get_password()
repo_type = xml_repo.get_type()
solver.add_repository(
SolverRepository(Uri(repo_source, repo_type), repo_user,
repo_secret))
return solver
def test_translate_obs_uri_not_found(mock_buildservice, mock_request_get,
self):
mock_buildservice.return_value = False
mock_request_get.side_effect = Exception('error')
uri = Uri('obs://openSUSE:Leap:42.2/standard', 'yast2')
self.runtime_config.get_obs_download_server_url = mock.Mock(
return_value='http://obs_server')
uri.runtime_config = self.runtime_config
with raises(KiwiUriOpenError) as exception_info:
uri.translate(check_build_environment=False)
assert f'{exception_info.value}' == \
'http://obs_server/openSUSE:/Leap:/42.2/standard: error'
def _setup_solver(self):
solver = Sat()
for xml_repo in self.xml_state.get_repository_sections_used_for_build(
):
repo_source = xml_repo.get_source().get_path()
repo_sourcetype = xml_repo.get_sourcetype() or ''
repo_user = xml_repo.get_username()
repo_secret = xml_repo.get_password()
repo_type = xml_repo.get_type()
repo_dist = xml_repo.get_distribution()
repo_components = xml_repo.get_components()
if not repo_type:
repo_type = SolverRepositoryBase(
Uri(uri=repo_source, source_type=repo_sourcetype),
repo_user, repo_secret).get_repo_type()
if repo_type == 'apt-deb':
# Debian based repos can be setup for a specific
# distribution including a list of individual components.
# For each component of the selected distribution extra
# repository metadata exists. In such a case we iterate
# over the configured dist components and add them as
# repository each.
dist_type = solver.set_dist_type('deb')
if repo_components and repo_dist:
for component in repo_components.split():
repo_source_for_component = os.sep.join([
repo_source.rstrip(os.sep), 'dists', repo_dist,
component, f'binary-{dist_type.get("arch")}'
])
solver.add_repository(
SolverRepository.new(
Uri(repo_source_for_component, repo_type,
repo_sourcetype), repo_user, repo_secret))
continue
solver.add_repository(
SolverRepository.new(
Uri(repo_source, repo_type, repo_sourcetype), repo_user,
repo_secret))
return solver
def test_translate_iso_path(self, mock_mkdtemp, mock_manager):
mock_mkdtemp.return_value = 'tmpdir'
manager = mock.Mock()
manager.mountpoint = mock_mkdtemp.return_value
mock_manager.return_value = manager
uri = Uri('iso:///image/CDs/openSUSE-13.2-DVD-x86_64.iso', 'yast2')
result = uri.translate()
mock_manager.assert_called_once_with(
device='/image/CDs/openSUSE-13.2-DVD-x86_64.iso',
mountpoint='tmpdir')
manager.mount.assert_called_once_with()
assert result == 'tmpdir'
uri.mount_stack = []
def test_extract_oci_image_without_tag(self, mock_run, mock_mkdtemp,
mock_path, mock_tar):
mock_path.return_value = True
tmpdirs = ['kiwi_uncompressed', 'kiwi_unpack_dir', 'kiwi_layout_dir']
def call_mkdtemp(prefix):
return tmpdirs.pop()
mock_mkdtemp.side_effect = call_mkdtemp
oci_import = RootImportOCI('root_dir', Uri('file:///image.tar.xz'))
oci_import.extract_oci_image()
mock_run.assert_called_once_with(
['skopeo', 'copy', 'oci:kiwi_uncompressed', 'oci:kiwi_layout_dir'])
mock_tar.assert_called_once_with('/image.tar.xz')
def import_repositories_marked_as_imageinclude(self) -> None:
"""
Those <repository> sections which are marked with the
imageinclude attribute should be permanently added to
the image repository configuration
"""
repository_sections = \
self.xml_state.get_repository_sections_used_in_image()
root = RootInit(
root_dir=self.root_dir, allow_existing=True
)
repo = Repository.new(
RootBind(root), self.xml_state.get_package_manager()
)
repo.use_default_location()
for xml_repo in repository_sections:
repo_type = xml_repo.get_type()
repo_source = xml_repo.get_source().get_path()
repo_user = xml_repo.get_username()
repo_secret = xml_repo.get_password()
repo_alias = xml_repo.get_alias()
repo_priority = xml_repo.get_priority()
repo_dist = xml_repo.get_distribution()
repo_components = xml_repo.get_components()
repo_repository_gpgcheck = xml_repo.get_repository_gpgcheck()
repo_package_gpgcheck = xml_repo.get_package_gpgcheck()
repo_customization_script = self._get_repo_customization_script(
xml_repo
)
repo_sourcetype = xml_repo.get_sourcetype()
repo_use_for_bootstrap = False
uri = Uri(repo_source, repo_type)
repo_source_translated = uri.translate(
check_build_environment=False
)
if not repo_alias:
repo_alias = uri.alias()
log.info('Setting up image repository {0}'.format(repo_source))
log.info('--> Type: {0}'.format(repo_type))
log.info('--> Translated: {0}'.format(repo_source_translated))
log.info('--> Alias: {0}'.format(repo_alias))
repo.add_repo(
repo_alias, repo_source_translated,
repo_type, repo_priority, repo_dist, repo_components,
repo_user, repo_secret, uri.credentials_file_name(),
repo_repository_gpgcheck, repo_package_gpgcheck,
repo_sourcetype, repo_use_for_bootstrap,
repo_customization_script
)
def test_extract_oci_image_unknown_uri(self, mock_buildservice, mock_warn,
mock_mkdtemp, mock_run,
mock_exists):
mock_buildservice.return_value = False
mock_exists.return_value = True
tmpdirs = ['kiwi_unpack_dir', 'kiwi_layout_dir']
def call_mkdtemp(prefix):
return tmpdirs.pop()
mock_mkdtemp.side_effect = call_mkdtemp
with patch.dict('os.environ', {'HOME': '../data'}):
docker_import = RootImportDocker('root_dir',
Uri('docker://opensuse'))
docker_import.extract_oci_image()
mock_run.assert_called_once_with(
['skopeo', 'copy', 'docker://opensuse', 'oci:kiwi_layout_dir'])
assert mock_warn.called
def test_extract_oci_image_unknown_uri(
self, mock_warn, mock_mkdtemp, mock_run, mock_exists
):
mock_exists.return_value = True
tmpdirs = ['kiwi_unpack_dir', 'kiwi_layout_dir']
def call_mkdtemp(prefix):
return tmpdirs.pop()
mock_mkdtemp.side_effect = call_mkdtemp
docker_import = RootImportDocker(
'root_dir', Uri('docker://opensuse')
)
docker_import.extract_oci_image()
mock_run.assert_called_once_with([
'skopeo', 'copy', 'docker://opensuse',
'oci:kiwi_layout_dir'
])
assert mock_warn.called
def setup(self, mock_exists, mock_machine):
mock_exists.return_value = True
mock_machine.return_value = 'x86_64'
self.uri = Uri('file:///image_file.tar.xz')
self.xml_state = mock.Mock()
self.xml_state.get_derived_from_image_uri.return_value = self.uri
self.container_config = {
'container_name': 'my-container',
'entry_command': ["--config.cmd='/bin/bash'"]
}
self.xml_state.get_container_config = mock.Mock(
return_value=self.container_config)
self.xml_state.get_image_version = mock.Mock(return_value='1.2.3')
self.xml_state.get_build_type_name = mock.Mock(return_value='docker')
self.xml_state.xml_data.get_name = mock.Mock(return_value='image_name')
self.setup = mock.Mock()
kiwi.builder.container.SystemSetup = mock.Mock(return_value=self.setup)
self.container = ContainerBuilder(self.xml_state, 'target_dir',
'root_dir')
self.container.result = mock.Mock()
def test_sync_data_unknown_uri(self, mock_OCI, mock_path, mock_md5,
mock_exists):
mock_exists.return_value = True
oci = Mock()
mock_OCI.return_value = oci
md5 = Mock()
mock_md5.return_value = Mock()
with patch.dict('os.environ', {'HOME': '../data'}):
oci_import = RootImportOCI('root_dir', Uri('docker:image:tag'),
{'archive_transport': 'docker-archive'})
with self._caplog.at_level(logging.WARNING):
oci_import.sync_data()
mock_OCI.assert_called_once_with()
oci.import_container_image.assert_called_once_with(
'docker:image:tag')
oci.unpack.assert_called_once_with()
oci.import_rootfs.assert_called_once_with('root_dir')
mock_md5.assert_called_once_with('root_dir/image/imported_root')
md5.md5.called_once_with('root_dir/image/imported_root.md5')
def setup(self, mock_exists, mock_machine):
mock_machine.return_value = 'x86_64'
with patch.dict('os.environ', {'HOME': '../data'}):
self.uri = Uri('file:///image_file.tar.xz')
self.xml_state = mock.Mock()
self.xml_state.get_derived_from_image_uri.return_value = self.uri
self.container_config = {
'container_name': 'my-container',
'entry_command': ["--config.cmd='/bin/bash'"]
}
self.xml_state.get_container_config = mock.Mock(
return_value=self.container_config
)
self.xml_state.get_image_version = mock.Mock(
return_value='1.2.3'
)
self.xml_state.get_build_type_name = mock.Mock(
return_value='docker'
)
self.xml_state.xml_data.get_name = mock.Mock(
return_value='image_name'
)
self.setup = mock.Mock()
kiwi.builder.container.SystemSetup = mock.Mock(
return_value=self.setup
)
def side_effect(filename):
if filename.endswith('.config/kiwi/config.yml'):
return False
elif filename.endswith('etc/kiwi.yml'):
return False
else:
return True
mock_exists.side_effect = side_effect
self.container = ContainerBuilder(
self.xml_state, 'target_dir', 'root_dir'
)
self.container.result = mock.Mock()
def import_repositories_marked_as_imageinclude(self):
"""
Those <repository> sections which are marked with the
imageinclude attribute should be permanently added to
the image repository configuration
"""
repository_sections = self.xml_state.get_repository_sections()
root = RootInit(root_dir=self.root_dir, allow_existing=True)
repo = Repository(RootBind(root), self.xml_state.get_package_manager())
repo.use_default_location()
for xml_repo in repository_sections:
repo_marked_for_image_include = xml_repo.get_imageinclude()
if repo_marked_for_image_include:
repo_type = xml_repo.get_type()
repo_source = xml_repo.get_source().get_path()
repo_user = xml_repo.get_username()
repo_secret = xml_repo.get_password()
repo_alias = xml_repo.get_alias()
repo_priority = xml_repo.get_priority()
repo_dist = xml_repo.get_distribution()
repo_components = xml_repo.get_components()
repo_repository_gpgcheck = xml_repo.get_repository_gpgcheck()
repo_package_gpgcheck = xml_repo.get_package_gpgcheck()
uri = Uri(repo_source, repo_type)
repo_source_translated = uri.translate()
if not repo_alias:
repo_alias = uri.alias()
log.info('Setting up image repository %s', repo_source)
log.info('--> Type: %s', repo_type)
log.info('--> Translated: %s', repo_source_translated)
log.info('--> Alias: %s', repo_alias)
repo.add_repo(repo_alias, repo_source_translated, repo_type,
repo_priority, repo_dist, repo_components,
repo_user, repo_secret,
uri.credentials_file_name(),
repo_repository_gpgcheck, repo_package_gpgcheck)
def test_extract_oci_image(
self, mock_mkdtemp, mock_compress, mock_run, mock_exists
):
mock_exists.return_value = True
uncompress = mock.Mock()
uncompress.uncompressed_filename = 'tmp_uncompressed'
mock_compress.return_value = uncompress
tmpdirs = ['kiwi_unpack_dir', 'kiwi_layout_dir']
def call_mkdtemp(prefix):
return tmpdirs.pop()
mock_mkdtemp.side_effect = call_mkdtemp
docker_import = RootImportDocker(
'root_dir', Uri('file:///image.tar.xz')
)
docker_import.extract_oci_image()
mock_compress.assert_called_once_with('/image.tar.xz')
uncompress.uncompress.assert_called_once_with(True)
mock_run.assert_called_once_with([
'skopeo', 'copy', 'docker-archive:tmp_uncompressed',
'oci:kiwi_layout_dir'
])
def test_extract_uncompressed_oci_image(self, mock_buildservice,
mock_mkdtemp, mock_compress,
mock_run, mock_exists):
mock_buildservice.return_value = False
mock_exists.return_value = True
uncompress = mock.Mock()
uncompress.get_format = mock.Mock(return_value=None)
mock_compress.return_value = uncompress
tmpdirs = ['kiwi_unpack_dir', 'kiwi_layout_dir']
def call_mkdtemp(prefix):
return tmpdirs.pop()
mock_mkdtemp.side_effect = call_mkdtemp
with patch.dict('os.environ', {'HOME': '../data'}):
docker_import = RootImportDocker('root_dir',
Uri('file:///image.tar'))
docker_import.extract_oci_image()
mock_compress.assert_called_once_with('/image.tar')
mock_run.assert_called_once_with([
'skopeo', 'copy', 'docker-archive:/image.tar',
'oci:kiwi_layout_dir:base_layer'
])
def test_alias(self):
uri = Uri('https://example.com', 'rpm-md')
assert uri.alias() == hashlib.md5(
'https://example.com'.encode()).hexdigest()
def test_is_remote_in_buildservice(self, mock_buildservice):
mock_buildservice.return_value = True
uri = Uri('obs://openSUSE:Leap:42.2/standard', 'yast2')
assert uri.is_remote() is False
def test_get_fragment(self):
uri = Uri('file:///myimage.tar#tag')
assert uri.get_fragment() == 'tag'
uri = Uri('file:///myimage.tar')
assert uri.get_fragment() == ''
def test_translate_obs_uri_not_found(mock_request_get, self):
mock_request_get.side_effect = Exception
uri = Uri('obs://openSUSE:Leap:42.2/standard', 'yast2')
uri.runtime_config = self.runtime_config
with raises(KiwiUriOpenError):
uri.translate()
def test_translate_obsrepositories_outside_buildservice(
self, mock_buildservice):
mock_buildservice.return_value = False
uri = Uri('obsrepositories:/')
with raises(KiwiUriStyleUnknown):
uri.translate()
def test_translate_unsupported_style(self):
uri = Uri('ms://foo', 'rpm-md')
with raises(KiwiUriStyleUnknown):
uri.translate()
def test_translate_unknown_style(self):
uri = Uri('xxx', 'rpm-md')
with raises(KiwiUriStyleUnknown):
uri.translate()
def test_is_remote_raises_type_error(self):
uri = Uri('xtp://download.example.com', 'rpm-md')
with raises(KiwiUriTypeUnknown):
uri.is_remote()
def test_translate_buildservice_obsrepositories(self, mock_buildservice):
mock_buildservice.return_value = True
uri = Uri('obsrepositories:/')
assert uri.translate() == '/usr/src/packages/SOURCES/repos'
def test_is_remote_raises_style_error(self):
uri = Uri('xxx', 'rpm-md')
with raises(KiwiUriStyleUnknown):
uri.is_remote()
