def test_get_volumes(self):
description = XMLDescription('../data/example_lvm_default_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple(
'volume_type', [
'name',
'size',
'realpath',
'mountpoint',
'fullsize'
]
)
assert state.get_volumes() == [
volume_type(
name='LVusr_lib', size='size:1024',
realpath='usr/lib',
mountpoint=None, fullsize=False
),
volume_type(
name='LVRoot', size='freespace:500',
realpath='/',
mountpoint=None, fullsize=False
),
volume_type(
name='etc_volume', size='freespace:30',
realpath='etc',
mountpoint='LVetc', fullsize=False
),
volume_type(
name='bin_volume', size=None,
realpath='/usr/bin',
mountpoint='LVusr_bin', fullsize=True
)
]
def test_get_build_type_vmconfig_entries_for_vmx_type(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'vmx')
assert state.get_build_type_vmconfig_entries() == [
'numvcpus = "4"', 'cpuid.coresPerSocket = "2"'
]
def test_get_volumes_no_explicit_root_setup_other_fullsize_volume(self):
description = XMLDescription(
'../data/example_lvm_no_root_full_usr_config.xml'
)
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple(
'volume_type', [
'name',
'size',
'realpath',
'mountpoint',
'fullsize'
]
)
assert state.get_volumes() == [
volume_type(
name='LVusr', size=None, realpath='usr',
mountpoint=None, fullsize=True
),
volume_type(
name='LVRoot', size='freespace:30', realpath='/',
mountpoint=None, fullsize=False
)
]
class TestRuntimeChecker(object):
def setup(self):
description = XMLDescription("../data/example_runtime_checker_config.xml")
self.xml_state = XMLState(description.load())
self.runtime_checker = RuntimeChecker(self.xml_state)
@raises(KiwiRuntimeError)
def test_check_image_include_repos_http_resolvable(self):
self.runtime_checker.check_image_include_repos_http_resolvable()
@raises(KiwiRuntimeError)
def test_check_target_directory_not_in_shared_cache_1(self):
self.runtime_checker.check_target_directory_not_in_shared_cache("/var/cache//kiwi/foo")
@raises(KiwiRuntimeError)
def test_check_target_directory_not_in_shared_cache_2(self):
self.runtime_checker.check_target_directory_not_in_shared_cache("/var/cache/kiwi")
@raises(KiwiRuntimeError)
@patch("os.getcwd")
def test_check_target_directory_not_in_shared_cache_3(self, mock_getcwd):
mock_getcwd.return_value = "/"
self.runtime_checker.check_target_directory_not_in_shared_cache("var/cache/kiwi")
@raises(KiwiRuntimeError)
def test_check_target_directory_not_in_shared_cache_4(self):
self.runtime_checker.check_target_directory_not_in_shared_cache("//var/cache//kiwi/foo")
@raises(KiwiRuntimeError)
def test_check_repositories_configured(self):
self.xml_state.delete_repository_sections()
self.runtime_checker.check_repositories_configured()
def test_build_type_size_with_unpartitioned(self):
state = XMLState(self.description.load(), ['vmxFlavour'], 'vmx')
result = state.get_build_type_size()
assert result.mbytes == 3072
assert not result.additive
result = state.get_build_type_size(include_unpartitioned=True)
assert result.mbytes == 4096
assert not result.additive
def test_get_users(self):
description = XMLDescription('../data/example_multiple_users_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
users = state.get_users()
assert len(users) == 3
assert any(u.get_name() == 'root' for u in users)
assert any(u.get_name() == 'tux' for u in users)
assert any(u.get_name() == 'kiwi' for u in users)
def test_copy_bootdelete_packages_no_delete_section_in_boot_descr(self):
boot_description = XMLDescription(
'../data/isoboot/example-distribution-no-delete-section/config.xml'
)
boot_state = XMLState(
boot_description.load()
)
self.state.copy_bootdelete_packages(boot_state)
to_delete_packages = boot_state.get_to_become_deleted_packages()
assert 'vim' in to_delete_packages
def test_get_build_type_docker_containerconfig_section(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'docker')
containerconfig = state.get_build_type_containerconfig_section()
assert containerconfig.get_name() == \
'container_name'
assert containerconfig.get_maintainer() == \
'tux'
assert containerconfig.get_workingdir() == \
'/root'
def test_copy_bootincluded_packages_with_image_packages(self):
boot_description = XMLDescription(
'../data/isoboot/example-distribution/config.xml'
)
boot_state = XMLState(boot_description.load(), ['std'])
self.state.copy_bootincluded_packages(boot_state)
image_packages = boot_state.get_system_packages()
assert 'plymouth-branding-openSUSE' in image_packages
assert 'grub2-branding-openSUSE' in image_packages
assert 'gfxboot-branding-openSUSE' in image_packages
to_delete_packages = boot_state.get_to_become_deleted_packages()
assert 'gfxboot-branding-openSUSE' not in to_delete_packages
def setup(self, mock_machine):
mock_machine.return_value = 'x86_64'
description = XMLDescription(
'../data/example_config.xml'
)
self.state = XMLState(
description.load()
)
boot_description = XMLDescription(
'../data/isoboot/example-distribution/config.xml'
)
self.boot_state = XMLState(
boot_description.load()
)
def test_get_system_packages_some_arch(self, mock_machine):
mock_machine.return_value = 's390'
state = XMLState(
self.description.load()
)
assert state.get_system_packages() == [
'foo',
'gfxboot-branding-openSUSE',
'grub2-branding-openSUSE',
'ifplugd',
'iputils',
'kernel-default',
'openssh',
'plymouth-branding-openSUSE',
'vim'
]
def test_get_container_config_clear_commands(self):
expected_config = {
'maintainer': ['--author=tux'],
'entry_subcommand': [
'--clear=config.cmd'
],
'container_name': 'container_name',
'container_tag': 'container_tag',
'workingdir': ['--config.workingdir=/root'],
'user': ['--config.user=root'],
'entry_command': [
'--clear=config.entrypoint',
]
}
xml_data = self.description.load()
state = XMLState(xml_data, ['derivedContainer'], 'docker')
assert state.get_container_config() == expected_config
def setup(self):
self.description = XMLDescription(
'../data/example_runtime_checker_config.xml'
)
self.xml_state = XMLState(
self.description.load()
)
self.runtime_checker = RuntimeChecker(self.xml_state)
def test_get_initrd_system(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'vmx')
assert state.get_initrd_system() == 'dracut'
state = XMLState(xml_data, ['vmxFlavour'], 'iso')
assert state.get_initrd_system() == 'dracut'
state = XMLState(xml_data, ['vmxFlavour'], 'docker')
assert state.get_initrd_system() is None
state = XMLState(xml_data, [], 'oem')
assert state.get_initrd_system() == 'kiwi'
def load_xml_description(self, description_directory):
"""
Load, upgrade, validate XML description
Attributes
* :attr:`xml_data`
instance of XML data toplevel domain (image), stateless data
* :attr:`config_file`
used config file path
* :attr:`xml_state`
Instance of XMLState, stateful data
"""
from ..logger import log
log.info('Loading XML description')
config_file = description_directory + '/config.xml'
if not os.path.exists(config_file):
# alternative config file lookup location
config_file = description_directory + '/image/config.xml'
if not os.path.exists(config_file):
# glob config file search, first match wins
glob_match = description_directory + '/*.kiwi'
for kiwi_file in glob.iglob(glob_match):
config_file = kiwi_file
break
if not os.path.exists(config_file):
raise KiwiConfigFileNotFound(
'no XML description found in %s' % description_directory
)
description = XMLDescription(
config_file
)
self.xml_data = description.load()
self.config_file = config_file.replace('//', '/')
self.xml_state = XMLState(
self.xml_data,
self.global_args['--profile'],
self.global_args['--type']
)
log.info('--> loaded %s', self.config_file)
if self.xml_state.build_type:
log.info(
'--> Selected build type: %s',
self.xml_state.get_build_type_name()
)
if self.xml_state.profiles:
log.info(
'--> Selected profiles: %s',
','.join(self.xml_state.profiles)
)
self.runtime_checker = RuntimeChecker(self.xml_state)
def test_get_user_groups(self):
description = XMLDescription('../data/example_multiple_users_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert len(state.get_user_groups('root')) == 0
assert len(state.get_user_groups('tux')) == 1
assert any(grp == 'users' for grp in state.get_user_groups('tux'))
assert len(state.get_user_groups('kiwi')) == 3
assert any(grp == 'users' for grp in state.get_user_groups('kiwi'))
assert any(grp == 'kiwi' for grp in state.get_user_groups('kiwi'))
assert any(grp == 'admin' for grp in state.get_user_groups('kiwi'))
def test_init_with_derived_from_image(
self, mock_root_bind, mock_root_init, mock_root_import
):
description = XMLDescription(
description='../data/example_config.xml',
derived_from='derived/description'
)
xml = description.load()
root_init = mock.MagicMock()
mock_root_init.return_value = root_init
root_import = mock.Mock()
root_import.sync_data = mock.Mock()
mock_root_import.return_value = root_import
root_bind = mock.MagicMock()
root_bind.root_dir = 'root_dir'
mock_root_bind.return_value = root_bind
state = XMLState(
xml, profiles=['vmxFlavour'], build_type='docker'
)
uri = mock.Mock()
get_derived_from_image_uri = mock.Mock(
return_value=uri
)
state.get_derived_from_image_uri = get_derived_from_image_uri
SystemPrepare(
xml_state=state, root_dir='root_dir',
)
mock_root_init.assert_called_once_with(
'root_dir', False
)
root_init.create.assert_called_once_with()
mock_root_import.assert_called_once_with(
'root_dir', uri,
state.build_type.get_image()
)
root_import.sync_data.assert_called_once_with()
mock_root_bind.assert_called_once_with(
root_init
)
root_bind.setup_intermediate_config.assert_called_once_with()
root_bind.mount_kernel_file_systems.assert_called_once_with()
def test_get_volumes_no_explicit_root_setup(self):
description = XMLDescription('../data/example_lvm_no_root_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple(
'volume_type', [
'name',
'size',
'realpath',
'mountpoint',
'fullsize',
'attributes'
]
)
assert state.get_volumes() == [
volume_type(
name='LVRoot', size=None, realpath='/',
mountpoint=None, fullsize=True,
attributes=[]
)
]
def test_get_build_type_unpartitioned_bytes(self):
assert self.state.get_build_type_unpartitioned_bytes() == 0
state = XMLState(self.description.load(), ['vmxFlavour'], 'vmx')
assert state.get_build_type_unpartitioned_bytes() == 1073741824
state = XMLState(self.description.load(), ['vmxFlavour'], 'oem')
assert state.get_build_type_unpartitioned_bytes() == 0
state = XMLState(self.description.load(), ['ec2Flavour'], 'vmx')
assert state.get_build_type_unpartitioned_bytes() == 0
def test_get_container_config(self):
expected_config = {
'labels': [
'--config.label=somelabel=labelvalue',
'--config.label=someotherlabel=anotherlabelvalue'
],
'maintainer': ['--author=tux'],
'entry_subcommand': [
'--config.cmd=ls',
'--config.cmd=-l'
],
'container_name': 'container_name',
'container_tag': 'container_tag',
'additional_tags': ['current', 'foobar'],
'workingdir': ['--config.workingdir=/root'],
'environment': [
'--config.env=PATH=/bin:/usr/bin:/home/user/bin',
'--config.env=SOMEVAR=somevalue'
],
'user': ['--config.user=root'],
'volumes': [
'--config.volume=/tmp',
'--config.volume=/var/log'
],
'entry_command': [
'--config.entrypoint=/bin/bash',
'--config.entrypoint=-x'
],
'expose_ports': [
'--config.exposedports=80',
'--config.exposedports=8080'
]
}
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'docker')
assert state.get_container_config() == expected_config
def load_boot_xml_description(self):
"""
Load the boot image description referenced by the system image
description boot attribute
"""
log.info('Loading Boot XML description')
boot_description_directory = self.get_boot_description_directory()
if not boot_description_directory:
raise KiwiConfigFileNotFound(
'no boot reference specified in XML description'
)
boot_config_file = boot_description_directory + '/config.xml'
if not os.path.exists(boot_config_file):
raise KiwiConfigFileNotFound(
'no Boot XML description found in %s' %
boot_description_directory
)
boot_description = XMLDescription(
description=boot_config_file,
derived_from=self.xml_state.xml_data.description_dir
)
boot_image_profile = self.xml_state.build_type.get_bootprofile()
if not boot_image_profile:
boot_image_profile = 'default'
boot_kernel_profile = self.xml_state.build_type.get_bootkernel()
if not boot_kernel_profile:
boot_kernel_profile = 'std'
self.boot_xml_state = XMLState(
boot_description.load(), [boot_image_profile, boot_kernel_profile]
)
log.info('--> loaded %s', boot_config_file)
if self.boot_xml_state.build_type:
log.info(
'--> Selected build type: %s',
self.boot_xml_state.get_build_type_name()
)
if self.boot_xml_state.profiles:
log.info(
'--> Selected boot profiles: image: %s, kernel: %s',
boot_image_profile, boot_kernel_profile
)
def test_check_swap_name_used_with_lvm(self):
xml_state = XMLState(self.description.load(), ['vmxFlavour'], 'oem')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.check_swap_name_used_with_lvm()
def test_get_derived_from_image_uri(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['derivedContainer'], 'docker')
assert state.get_derived_from_image_uri().uri == \
'obs://project/repo/image#mytag'
def test_check_container_tool_chain_installed(self, mock_which):
mock_which.return_value = False
xml_state = XMLState(self.description.load(), ['docker'], 'docker')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.check_container_tool_chain_installed()
def test_check_volume_setup_defines_reserved_labels(self):
xml_state = XMLState(self.description.load(), ['vmxSimpleFlavour'],
'oem')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.check_volume_setup_defines_reserved_labels()
def test_get_build_type_oemconfig_section(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
state = XMLState(xml_data, None, 'oem')
assert state.get_build_type_oemconfig_section().get_oem_swap()[0] ==\
'true'
def test_profile_not_found(self):
xml_data = self.description.load()
with raises(KiwiProfileNotFound):
XMLState(xml_data, ['foo'])
def test_get_volume_management_lvm_default(self):
description = XMLDescription('../data/example_lvm_default_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'lvm'
def test_build_type_explicitly_selected(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_build_type_name() == 'oem'
def test_get_initrd_system(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_initrd_system() == 'dracut'
state = XMLState(xml_data, ['vmxSimpleFlavour'], 'iso')
assert state.get_initrd_system() == 'dracut'
state = XMLState(xml_data, ['containerFlavour'], 'docker')
assert state.get_initrd_system() is None
state = XMLState(xml_data, [], 'oem')
assert state.get_initrd_system() == 'dracut'
class TestXMLState:
@fixture(autouse=True)
def inject_fixtures(self, caplog):
self._caplog = caplog
def setup(self):
Defaults.set_platform_name('x86_64')
self.description = XMLDescription('../data/example_config.xml')
self.state = XMLState(self.description.load())
boot_description = XMLDescription(
'../data/isoboot/example-distribution/config.xml')
self.boot_state = XMLState(boot_description.load())
no_image_packages_description = XMLDescription(
'../data/example_no_image_packages_config.xml')
self.no_image_packages_boot_state = XMLState(
no_image_packages_description.load())
self.bootloader = Mock()
self.bootloader.get_name.return_value = 'some-loader'
self.bootloader.get_timeout.return_value = 'some-timeout'
self.bootloader.get_timeout_style.return_value = 'some-style'
self.bootloader.get_targettype.return_value = 'some-target'
self.bootloader.get_console.return_value = 'some-console'
self.bootloader.get_serial_line.return_value = 'some-serial'
def test_get_description_section(self):
description = self.state.get_description_section()
assert description.author == 'Marcus'
assert description.contact == '*****@*****.**'
assert description.specification == \
'Testing various configuration states'
def test_get_preferences_by_architecture(self):
Defaults.set_platform_name('aarch64')
state = XMLState(self.description.load())
preferences = state.get_preferences_sections()
Defaults.set_platform_name('x86_64')
assert len(preferences) == 3
assert preferences[2].get_arch() == 'aarch64'
assert state.get_build_type_name() == 'iso'
def test_build_type_primary_selected(self):
assert self.state.get_build_type_name() == 'oem'
def test_build_type_first_selected(self):
self.state.xml_data.get_preferences()[2].get_type()[0].set_primary(
False)
assert self.state.get_build_type_name() == 'oem'
@patch('kiwi.xml_state.XMLState.get_preferences_sections')
def test_get_rpm_excludedocs_without_entry(self, mock_preferences):
mock_preferences.return_value = []
assert self.state.get_rpm_excludedocs() is False
def test_get_rpm_excludedocs(self):
assert self.state.get_rpm_excludedocs() is True
@patch('kiwi.xml_state.XMLState.get_preferences_sections')
def test_get_rpm_check_signatures_without_entry(self, mock_preferences):
mock_preferences.return_value = []
assert self.state.get_rpm_check_signatures() is False
def test_get_rpm_check_signatures(self):
assert self.state.get_rpm_check_signatures() is True
def test_get_package_manager(self):
assert self.state.get_package_manager() == 'zypper'
@patch('kiwi.xml_state.XMLState.get_preferences_sections')
def test_get_default_package_manager(self, mock_preferences):
mock_preferences.return_value = []
assert self.state.get_package_manager() == 'dnf'
def test_get_image_version(self):
assert self.state.get_image_version() == '1.13.2'
def test_get_bootstrap_packages(self):
assert self.state.get_bootstrap_packages() == ['filesystem', 'zypper']
assert self.state.get_bootstrap_packages(plus_packages=['vim']) == [
'filesystem', 'vim', 'zypper'
]
assert self.no_image_packages_boot_state.get_bootstrap_packages() == [
'patterns-openSUSE-base'
]
def test_get_system_packages(self):
assert self.state.get_system_packages() == [
'gfxboot-branding-openSUSE', 'grub2-branding-openSUSE', 'ifplugd',
'iputils', 'kernel-default', 'openssh',
'plymouth-branding-openSUSE', 'vim'
]
def test_get_system_packages_some_arch(self):
Defaults.set_platform_name('s390')
state = XMLState(self.description.load())
assert state.get_system_packages() == [
'foo', 'gfxboot-branding-openSUSE', 'grub2-branding-openSUSE',
'ifplugd', 'iputils', 'kernel-default', 'openssh',
'plymouth-branding-openSUSE', 'vim'
]
Defaults.set_platform_name('x86_64')
def test_get_system_collections(self):
assert self.state.get_system_collections() == ['base']
def test_get_system_products(self):
assert self.state.get_system_products() == ['openSUSE']
def test_get_system_archives(self):
assert self.state.get_system_archives() == [
'/absolute/path/to/image.tgz'
]
def test_get_system_ignore_packages(self):
assert self.state.get_system_ignore_packages() == ['bar', 'baz', 'foo']
self.state.host_architecture = 'aarch64'
assert self.state.get_system_ignore_packages() == ['baz', 'foo']
self.state.host_architecture = 's390'
assert self.state.get_system_ignore_packages() == ['baz']
def test_get_system_collection_type(self):
assert self.state.get_system_collection_type() == 'plusRecommended'
def test_get_bootstrap_collections(self):
assert self.state.get_bootstrap_collections() == [
'bootstrap-collection'
]
def test_get_bootstrap_products(self):
assert self.state.get_bootstrap_products() == ['kiwi']
def test_get_bootstrap_archives(self):
assert self.state.get_bootstrap_archives() == ['bootstrap.tgz']
def test_get_bootstrap_collection_type(self):
assert self.state.get_bootstrap_collection_type() == 'onlyRequired'
def test_set_repository(self):
self.state.set_repository('repo', 'type', 'alias', 1, True, False)
assert self.state.xml_data.get_repository()[0].get_source().get_path() \
== 'repo'
assert self.state.xml_data.get_repository()[0].get_type() == 'type'
assert self.state.xml_data.get_repository()[0].get_alias() == 'alias'
assert self.state.xml_data.get_repository()[0].get_priority() == 1
assert self.state.xml_data.get_repository()[0] \
.get_imageinclude() is True
assert self.state.xml_data.get_repository()[0] \
.get_package_gpgcheck() is False
def test_add_repository(self):
self.state.add_repository('repo', 'type', 'alias', 1, True)
assert self.state.xml_data.get_repository()[3].get_source().get_path() \
== 'repo'
assert self.state.xml_data.get_repository()[3].get_type() == 'type'
assert self.state.xml_data.get_repository()[3].get_alias() == 'alias'
assert self.state.xml_data.get_repository()[3].get_priority() == 1
assert self.state.xml_data.get_repository()[3] \
.get_imageinclude() is True
def test_add_repository_with_empty_values(self):
self.state.add_repository('repo', 'type', '', '', True)
assert self.state.xml_data.get_repository()[3].get_source().get_path() \
== 'repo'
assert self.state.xml_data.get_repository()[3].get_type() == 'type'
assert self.state.xml_data.get_repository()[3].get_alias() == ''
assert self.state.xml_data.get_repository()[3].get_priority() is None
assert self.state.xml_data.get_repository()[3] \
.get_imageinclude() is True
def test_get_to_become_deleted_packages(self):
assert self.state.get_to_become_deleted_packages() == ['kernel-debug']
def test_get_build_type_vagrant_config_section(self):
vagrant_config = self.state.get_build_type_vagrant_config_section()
assert vagrant_config.get_provider() == 'libvirt'
assert self.boot_state.get_build_type_vagrant_config_section() is None
def test_virtualbox_guest_additions_vagrant_config_section(self):
assert not self.state.get_vagrant_config_virtualbox_guest_additions()
def test_virtualbox_guest_additions_vagrant_config_section_missing(self):
self.state. \
get_build_type_vagrant_config_section() \
.virtualbox_guest_additions_present = True
assert self.state.get_vagrant_config_virtualbox_guest_additions()
def test_get_build_type_system_disk_section(self):
assert self.state.get_build_type_system_disk_section().get_name() == \
'mydisk'
def test_get_build_type_vmdisk_section(self):
assert self.state.get_build_type_vmdisk_section().get_id() == 0
assert self.boot_state.get_build_type_vmdisk_section() is None
def test_get_build_type_vmnic_entries(self):
assert self.state.get_build_type_vmnic_entries()[0].get_interface() \
== ''
assert self.boot_state.get_build_type_vmnic_entries() == []
def test_get_build_type_vmdvd_section(self):
assert self.state.get_build_type_vmdvd_section().get_id() == 0
assert self.boot_state.get_build_type_vmdvd_section() is None
def test_get_volume_management(self):
assert self.state.get_volume_management() == 'lvm'
def test_get_volume_management_none(self):
assert self.boot_state.get_volume_management() is None
def test_get_volume_management_btrfs(self):
description = XMLDescription('../data/example_btrfs_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'btrfs'
def test_get_volume_management_lvm_prefer(self):
description = XMLDescription(
'../data/example_lvm_preferred_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'lvm'
def test_get_volume_management_lvm_default(self):
description = XMLDescription('../data/example_lvm_default_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'lvm'
def test_build_type_explicitly_selected(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_build_type_name() == 'oem'
def test_build_type_not_found(self):
xml_data = self.description.load()
with raises(KiwiTypeNotFound):
XMLState(xml_data, ['vmxFlavour'], 'foo')
def test_build_type_not_found_no_default_type(self):
description = XMLDescription('../data/example_no_default_type.xml')
xml_data = description.load()
with raises(KiwiTypeNotFound):
XMLState(xml_data, ['minimal'])
def test_profile_not_found(self):
xml_data = self.description.load()
with raises(KiwiProfileNotFound):
XMLState(xml_data, ['foo'])
def test_profile_requires(self):
xml_data = self.description.load()
xml_state = XMLState(xml_data, ['composedProfile'])
assert xml_state.profiles == [
'composedProfile', 'vmxSimpleFlavour', 'xenDomUFlavour'
]
def test_get_volumes_custom_root_volume_name(self):
description = XMLDescription(
'../data/example_lvm_custom_rootvol_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple('volume_type', [
'name', 'size', 'realpath', 'mountpoint', 'fullsize', 'label',
'attributes', 'is_root_volume'
])
assert state.get_volumes() == [
volume_type(name='myroot',
size='freespace:500',
realpath='/',
mountpoint=None,
fullsize=False,
label=None,
attributes=[],
is_root_volume=True)
]
def test_get_volumes(self):
description = XMLDescription('../data/example_lvm_default_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple('volume_type', [
'name', 'size', 'realpath', 'mountpoint', 'fullsize', 'label',
'attributes', 'is_root_volume'
])
assert state.get_volumes() == [
volume_type(name='usr_lib',
size='size:1024',
realpath='usr/lib',
mountpoint='usr/lib',
fullsize=False,
label='library',
attributes=[],
is_root_volume=False),
volume_type(name='LVRoot',
size='freespace:500',
realpath='/',
mountpoint=None,
fullsize=False,
label=None,
attributes=[],
is_root_volume=True),
volume_type(
name='etc_volume',
size='freespace:30',
realpath='etc',
mountpoint='etc',
fullsize=False,
label=None,
attributes=['no-copy-on-write', 'enable-for-filesystem-check'],
is_root_volume=False),
volume_type(name='bin_volume',
size=None,
realpath='/usr/bin',
mountpoint='/usr/bin',
fullsize=True,
label=None,
attributes=[],
is_root_volume=False),
volume_type(name='LVSwap',
size='size:128',
realpath='swap',
mountpoint=None,
fullsize=False,
label='SWAP',
attributes=[],
is_root_volume=False)
]
def test_get_volumes_no_explicit_root_setup(self):
description = XMLDescription('../data/example_lvm_no_root_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple('volume_type', [
'name', 'size', 'realpath', 'mountpoint', 'fullsize', 'label',
'attributes', 'is_root_volume'
])
assert state.get_volumes() == [
volume_type(name='LVRoot',
size=None,
realpath='/',
mountpoint=None,
fullsize=True,
label=None,
attributes=[],
is_root_volume=True),
volume_type(name='LVSwap',
size='size:128',
realpath='swap',
mountpoint=None,
fullsize=False,
label='SWAP',
attributes=[],
is_root_volume=False)
]
def test_get_volumes_no_explicit_root_setup_other_fullsize_volume(self):
description = XMLDescription(
'../data/example_lvm_no_root_full_usr_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple('volume_type', [
'name', 'size', 'realpath', 'mountpoint', 'fullsize', 'label',
'attributes', 'is_root_volume'
])
assert state.get_volumes() == [
volume_type(name='usr',
size=None,
realpath='usr',
mountpoint='usr',
fullsize=True,
label=None,
attributes=[],
is_root_volume=False),
volume_type(name='LVRoot',
size='freespace:30',
realpath='/',
mountpoint=None,
fullsize=False,
label=None,
attributes=[],
is_root_volume=True),
volume_type(name='LVSwap',
size='size:128',
realpath='swap',
mountpoint=None,
fullsize=False,
label='SWAP',
attributes=[],
is_root_volume=False)
]
@patch('kiwi.xml_state.XMLState.get_build_type_system_disk_section')
def test_get_empty_volumes(self, mock_system_disk):
mock_system_disk.return_value = None
assert self.state.get_volumes() == []
def test_get_strip_files_to_delete(self):
assert self.state.get_strip_files_to_delete() == ['del-a', 'del-b']
def test_get_strip_tools_to_keep(self):
assert self.state.get_strip_tools_to_keep() == ['tool-a', 'tool-b']
def test_get_strip_libraries_to_keep(self):
assert self.state.get_strip_libraries_to_keep() == ['lib-a', 'lib-b']
def test_get_build_type_machine_section(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxSimpleFlavour'], 'oem')
assert state.get_build_type_machine_section().get_guestOS() == 'suse'
def test_get_drivers_list(self):
assert self.state.get_drivers_list() == \
['crypto/*', 'drivers/acpi/*', 'bar']
def test_get_build_type_oemconfig_section(self):
xml_data = self.description.load()
state = XMLState(xml_data, None, 'oem')
assert state.get_build_type_oemconfig_section().get_oem_swap()[0] is \
True
def test_get_oemconfig_oem_resize(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_oemconfig_oem_resize() is True
description = XMLDescription(
'../data/example_multiple_users_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_oemconfig_oem_resize() is False
def test_get_oemconfig_oem_multipath_scan(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_oemconfig_oem_multipath_scan() is False
description = XMLDescription('../data/example_disk_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_oemconfig_oem_multipath_scan() is False
def test_get_oemconfig_swap_mbytes(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
assert state.get_oemconfig_swap_mbytes() is None
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_oemconfig_swap_mbytes() == 42
def test_get_oemconfig_swap_name(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
assert state.get_oemconfig_swap_name() == 'LVSwap'
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_oemconfig_swap_name() == 'swap'
def test_get_oemconfig_swap_mbytes_default(self):
description = XMLDescription('../data/example_btrfs_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_oemconfig_swap_mbytes() == 128
def test_get_users_sections(self):
assert self.state.get_users_sections()[0].get_user()[0].get_name() == \
'root'
def test_get_users(self):
description = XMLDescription(
'../data/example_multiple_users_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
users = state.get_users()
assert len(users) == 3
assert any(u.get_name() == 'root' for u in users)
assert any(u.get_name() == 'tux' for u in users)
assert any(u.get_name() == 'kiwi' for u in users)
def test_get_user_groups(self):
description = XMLDescription(
'../data/example_multiple_users_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert len(state.get_user_groups('root')) == 0
assert len(state.get_user_groups('tux')) == 1
assert any(grp == 'users' for grp in state.get_user_groups('tux'))
assert len(state.get_user_groups('kiwi')) == 3
assert any(grp == 'users' for grp in state.get_user_groups('kiwi'))
assert any(grp == 'kiwi' for grp in state.get_user_groups('kiwi'))
assert any(grp == 'admin' for grp in state.get_user_groups('kiwi'))
def test_copy_displayname(self):
self.state.copy_displayname(self.boot_state)
assert self.boot_state.xml_data.get_displayname() == 'Bob'
def test_copy_drivers_sections(self):
self.state.copy_drivers_sections(self.boot_state)
assert 'bar' in self.boot_state.get_drivers_list()
def test_copy_systemdisk_section(self):
self.state.copy_systemdisk_section(self.boot_state)
systemdisk = self.boot_state.get_build_type_system_disk_section()
assert systemdisk.get_name() == 'mydisk'
@patch('kiwi.xml_parse.type_.get_bootloader')
def test_copy_bootloader_section(self, mock_bootloader):
mock_bootloader.return_value = [self.bootloader]
self.state.copy_bootloader_section(self.boot_state)
assert self.boot_state.get_build_type_bootloader_section() == \
self.bootloader
def test_copy_strip_sections(self):
self.state.copy_strip_sections(self.boot_state)
assert 'del-a' in self.boot_state.get_strip_files_to_delete()
def test_copy_machine_section(self):
self.state.copy_machine_section(self.boot_state)
machine = self.boot_state.get_build_type_machine_section()
assert machine.get_memory() == 512
def test_copy_oemconfig_section(self):
self.state.copy_oemconfig_section(self.boot_state)
oemconfig = self.boot_state.get_build_type_oemconfig_section()
assert oemconfig.get_oem_systemsize()[0] == 2048
def test_copy_repository_sections(self):
self.state.copy_repository_sections(self.boot_state, True)
repository = self.boot_state.get_repository_sections()[0]
assert repository.get_source().get_path() == 'iso:///image/CDs/dvd.iso'
def test_copy_preferences_subsections(self):
self.state.copy_preferences_subsections(['bootsplash_theme'],
self.boot_state)
preferences = self.boot_state.get_preferences_sections()[0]
assert preferences.get_bootsplash_theme()[0] == 'openSUSE'
def test_copy_build_type_attributes(self):
self.state.copy_build_type_attributes(['firmware'], self.boot_state)
assert self.boot_state.build_type.get_firmware() == 'efi'
def test_copy_bootincluded_packages_with_no_image_packages(self):
self.state.copy_bootincluded_packages(self.boot_state)
bootstrap_packages = self.boot_state.get_bootstrap_packages()
assert 'plymouth-branding-openSUSE' in bootstrap_packages
assert 'grub2-branding-openSUSE' in bootstrap_packages
assert 'gfxboot-branding-openSUSE' in bootstrap_packages
to_delete_packages = self.boot_state.get_to_become_deleted_packages()
assert 'gfxboot-branding-openSUSE' not in to_delete_packages
def test_copy_bootincluded_packages_with_image_packages(self):
boot_description = XMLDescription(
'../data/isoboot/example-distribution/config.xml')
boot_state = XMLState(boot_description.load(), ['std'])
self.state.copy_bootincluded_packages(boot_state)
image_packages = boot_state.get_system_packages()
assert 'plymouth-branding-openSUSE' in image_packages
assert 'grub2-branding-openSUSE' in image_packages
assert 'gfxboot-branding-openSUSE' in image_packages
to_delete_packages = boot_state.get_to_become_deleted_packages()
assert 'gfxboot-branding-openSUSE' not in to_delete_packages
def test_copy_bootincluded_archives(self):
self.state.copy_bootincluded_archives(self.boot_state)
bootstrap_archives = self.boot_state.get_bootstrap_archives()
assert '/absolute/path/to/image.tgz' in bootstrap_archives
def test_copy_bootdelete_packages(self):
self.state.copy_bootdelete_packages(self.boot_state)
to_delete_packages = self.boot_state.get_to_become_deleted_packages()
assert 'vim' in to_delete_packages
def test_copy_bootdelete_packages_no_delete_section_in_boot_descr(self):
boot_description = XMLDescription(
'../data/isoboot/example-distribution-no-delete-section/config.xml'
)
boot_state = XMLState(boot_description.load())
self.state.copy_bootdelete_packages(boot_state)
to_delete_packages = boot_state.get_to_become_deleted_packages()
assert 'vim' in to_delete_packages
def test_build_type_size(self):
result = self.state.get_build_type_size()
assert result.mbytes == 1024
assert result.additive
def test_build_type_size_with_unpartitioned(self):
state = XMLState(self.description.load(), ['vmxSimpleFlavour'], 'oem')
result = state.get_build_type_size()
assert result.mbytes == 3072
assert not result.additive
result = state.get_build_type_size(include_unpartitioned=True)
assert result.mbytes == 4096
assert not result.additive
def test_get_build_type_unpartitioned_bytes(self):
assert self.state.get_build_type_unpartitioned_bytes() == 0
state = XMLState(self.description.load(), ['vmxSimpleFlavour'], 'oem')
assert state.get_build_type_unpartitioned_bytes() == 1073741824
state = XMLState(self.description.load(), ['vmxFlavour'], 'oem')
assert state.get_build_type_unpartitioned_bytes() == 0
state = XMLState(self.description.load(), ['ec2Flavour'], 'oem')
assert state.get_build_type_unpartitioned_bytes() == 0
def test_get_volume_group_name(self):
assert self.state.get_volume_group_name() == 'mydisk'
def test_get_volume_group_name_default(self):
assert self.boot_state.get_volume_group_name() == 'systemVG'
def test_get_distribution_name_from_boot_attribute(self):
assert self.state.get_distribution_name_from_boot_attribute() == \
'distribution'
def test_get_fs_mount_option_list(self):
assert self.state.get_fs_mount_option_list() == ['async']
def test_get_fs_create_option_list(self):
assert self.state.get_fs_create_option_list() == ['-O', '^has_journal']
@patch('kiwi.xml_parse.type_.get_boot')
def test_get_distribution_name_from_boot_attribute_no_boot(
self, mock_boot):
mock_boot.return_value = None
with raises(KiwiDistributionNameError):
self.state.get_distribution_name_from_boot_attribute()
@patch('kiwi.xml_parse.type_.get_boot')
def test_get_distribution_name_from_boot_attribute_invalid_boot(
self, mock_boot):
mock_boot.return_value = 'invalid'
with raises(KiwiDistributionNameError):
self.state.get_distribution_name_from_boot_attribute()
def test_delete_repository_sections(self):
self.state.delete_repository_sections()
assert self.state.get_repository_sections() == []
def test_delete_repository_sections_used_for_build(self):
self.state.delete_repository_sections_used_for_build()
assert self.state.get_repository_sections()[0].get_imageonly()
def test_get_build_type_vmconfig_entries(self):
assert self.state.get_build_type_vmconfig_entries() == []
def test_get_build_type_vmconfig_entries_for_simple_disk(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxSimpleFlavour'], 'oem')
assert state.get_build_type_vmconfig_entries() == [
'numvcpus = "4"', 'cpuid.coresPerSocket = "2"'
]
def test_get_build_type_vmconfig_entries_no_machine_section(self):
description = XMLDescription('../data/example_disk_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_build_type_vmconfig_entries() == []
def test_get_build_type_docker_containerconfig_section(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
containerconfig = state.get_build_type_containerconfig_section()
assert containerconfig.get_name() == \
'container_name'
assert containerconfig.get_maintainer() == \
'tux'
assert containerconfig.get_workingdir() == \
'/root'
def test_set_container_tag(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
state.set_container_config_tag('new_tag')
config = state.get_container_config()
assert config['container_tag'] == 'new_tag'
def test_add_container_label(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
state.add_container_config_label('somelabel', 'overwrittenvalue')
state.add_container_config_label('new_label', 'new value')
config = state.get_container_config()
assert config['labels'] == {
'somelabel': 'overwrittenvalue',
'someotherlabel': 'anotherlabelvalue',
'new_label': 'new value'
}
def test_add_container_label_without_contianerconfig(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['xenDom0Flavour'], 'docker')
state.add_container_config_label('somelabel', 'newlabelvalue')
config = state.get_container_config()
assert config['labels'] == {'somelabel': 'newlabelvalue'}
def test_add_container_label_no_container_image_type(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
state.add_container_config_label('somelabel', 'newlabelvalue')
with self._caplog.at_level(logging.WARNING):
config = state.get_container_config()
assert config == {
'history': {
'author': 'Marcus <*****@*****.**>'
},
'maintainer': 'Marcus <*****@*****.**>'
}
def test_set_container_tag_not_applied(self):
with self._caplog.at_level(logging.WARNING):
self.state.set_container_config_tag('new_tag')
def test_get_container_config(self):
expected_config = {
'labels': {
'somelabel': 'labelvalue',
'someotherlabel': 'anotherlabelvalue'
},
'maintainer': 'tux',
'entry_subcommand': ['ls', '-l'],
'container_name': 'container_name',
'container_tag': 'container_tag',
'additional_tags': ['current', 'foobar'],
'workingdir': '/root',
'environment': {
'PATH': '/bin:/usr/bin:/home/user/bin',
'SOMEVAR': 'somevalue'
},
'user': '******',
'volumes': ['/tmp', '/var/log'],
'entry_command': ['/bin/bash', '-x'],
'expose_ports': ['80', '8080'],
'history': {
'author': 'history author',
'comment': 'This is a comment',
'created_by': 'created by text',
'application_id': '123',
'package_version': '2003.12.0.0',
'launcher': 'app'
}
}
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
assert state.get_container_config() == expected_config
def test_get_container_config_clear_commands(self):
expected_config = {
'maintainer': 'tux',
'entry_subcommand': [],
'container_name': 'container_name',
'container_tag': 'container_tag',
'workingdir': '/root',
'user': '******',
'entry_command': [],
'history': {
'author': 'Marcus <*****@*****.**>'
}
}
xml_data = self.description.load()
state = XMLState(xml_data, ['derivedContainer'], 'docker')
assert state.get_container_config() == expected_config
def test_get_spare_part(self):
assert self.state.get_build_type_spare_part_size() == 200
assert self.state.get_build_type_spare_part_fs_attributes() == [
'no-copy-on-write'
]
def test_get_build_type_format_options(self):
assert self.state.get_build_type_format_options() == {
'super': 'man',
'force_size': None
}
def test_get_derived_from_image_uri(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['derivedContainer'], 'docker')
assert state.get_derived_from_image_uri().uri == \
'obs://project/repo/image#mytag'
def test_set_derived_from_image_uri(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['derivedContainer'], 'docker')
state.set_derived_from_image_uri('file:///new_uri')
assert state.get_derived_from_image_uri().translate() == '/new_uri'
def test_set_derived_from_image_uri_not_applied(self):
with self._caplog.at_level(logging.WARNING):
self.state.set_derived_from_image_uri('file:///new_uri')
def test_is_xen_server(self):
assert self.state.is_xen_server() is True
def test_is_xen_guest_by_machine_setup(self):
assert self.state.is_xen_guest() is True
def test_is_xen_guest_no_xen_guest_setup(self):
assert self.boot_state.is_xen_guest() is False
def test_is_xen_guest_by_firmware_setup(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['ec2Flavour'], 'oem')
assert state.is_xen_guest() is True
def test_is_xen_guest_by_architecture(self):
Defaults.set_platform_name('unsupported')
xml_data = self.description.load()
state = XMLState(xml_data, ['ec2Flavour'], 'oem')
assert state.is_xen_guest() is False
Defaults.set_platform_name('x86_64')
def test_get_initrd_system(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_initrd_system() == 'dracut'
state = XMLState(xml_data, ['vmxSimpleFlavour'], 'iso')
assert state.get_initrd_system() == 'dracut'
state = XMLState(xml_data, ['containerFlavour'], 'docker')
assert state.get_initrd_system() == 'none'
state = XMLState(xml_data, [], 'oem')
assert state.get_initrd_system() == 'dracut'
def test_get_rpm_locale_filtering(self):
assert self.state.get_rpm_locale_filtering() is True
assert self.boot_state.get_rpm_locale_filtering() is False
def test_get_locale(self):
assert self.state.get_locale() == ['en_US', 'de_DE']
assert self.boot_state.get_locale() is None
def test_get_rpm_locale(self):
assert self.state.get_rpm_locale() == [
'POSIX', 'C', 'C.UTF-8', 'en_US', 'de_DE'
]
assert self.boot_state.get_rpm_locale() is None
def test_set_root_partition_uuid(self):
assert self.state.get_root_partition_uuid() is None
self.state.set_root_partition_uuid('some-id')
assert self.state.get_root_partition_uuid() == 'some-id'
def test_set_root_filesystem_uuid(self):
assert self.state.get_root_filesystem_uuid() is None
self.state.set_root_filesystem_uuid('some-id')
assert self.state.get_root_filesystem_uuid() == 'some-id'
@patch('kiwi.xml_parse.type_.get_bootloader')
def test_get_build_type_bootloader_name(self, mock_bootloader):
mock_bootloader.return_value = [None]
assert self.state.get_build_type_bootloader_name() == 'grub2'
mock_bootloader.return_value = [self.bootloader]
assert self.state.get_build_type_bootloader_name() == 'some-loader'
@patch('kiwi.xml_parse.type_.get_bootloader')
def test_get_build_type_bootloader_console(self, mock_bootloader):
mock_bootloader.return_value = [self.bootloader]
assert self.state.get_build_type_bootloader_console() == \
'some-console'
@patch('kiwi.xml_parse.type_.get_bootloader')
def test_get_build_type_bootloader_serial_line_setup(
self, mock_bootloader):
mock_bootloader.return_value = [self.bootloader]
assert self.state.get_build_type_bootloader_serial_line_setup() == \
'some-serial'
mock_bootloader.return_value = [None]
assert self.state.get_build_type_bootloader_serial_line_setup() \
is None
@patch('kiwi.xml_parse.type_.get_bootloader')
def test_get_build_type_bootloader_timeout(self, mock_bootloader):
mock_bootloader.return_value = [self.bootloader]
assert self.state.get_build_type_bootloader_timeout() == \
'some-timeout'
@patch('kiwi.xml_parse.type_.get_bootloader')
def test_get_build_type_bootloader_timeout_style(self, mock_bootloader):
mock_bootloader.return_value = [self.bootloader]
assert self.state.get_build_type_bootloader_timeout_style() == \
'some-style'
mock_bootloader.return_value = [None]
assert self.state.get_build_type_bootloader_timeout_style() \
is None
@patch('kiwi.xml_parse.type_.get_bootloader')
def test_get_build_type_bootloader_targettype(self, mock_bootloader):
mock_bootloader.return_value = [self.bootloader]
assert self.state.get_build_type_bootloader_targettype() == \
'some-target'
def test_get_installintrd_modules(self):
self.state.get_installmedia_initrd_modules('add') == ['network-legacy']
self.state.get_installmedia_initrd_modules('set') == []
self.state.get_installmedia_initrd_modules('omit') == []
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxSimpleFlavour'], 'oem')
state.get_installmedia_initrd_modules('add') == []
def test_is_xen_guest_by_architecture(self, mock_platform_machine):
mock_platform_machine.return_value = 'unsupported'
xml_data = self.description.load()
state = XMLState(xml_data, ['ec2Flavour'], 'oem')
assert state.is_xen_guest() is False
def test_is_xen_guest_by_firmware_setup(self, mock_platform_machine):
mock_platform_machine.return_value = 'x86_64'
xml_data = self.description.load()
state = XMLState(xml_data, ['ec2Flavour'], 'oem')
assert state.is_xen_guest() is True
def test_set_derived_from_image_uri(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['derivedContainer'], 'docker')
state.set_derived_from_image_uri('file:///new_uri')
assert state.get_derived_from_image_uri().translate() == '/new_uri'
def test_get_volumes_invalid_mountpoint(self):
description = XMLDescription('../data/example_lvm_invalid_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['invalid_volume_b'])
state.get_volumes()
def test_build_type_not_found(self):
xml_data = self.description.load()
with raises(KiwiTypeNotFound):
XMLState(xml_data, ['vmxFlavour'], 'foo')
def test_get_build_type_machine_section(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
state = XMLState(xml_data, None, 'vmx')
assert state.get_build_type_machine_section().get_guestOS() == 'suse'
def test_check_mediacheck_installed_tagmedia_missing(self, mock_which):
mock_which.return_value = False
xml_state = XMLState(self.description.load(), ['vmxFlavour'], 'iso')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.check_mediacheck_installed()
def test_set_container_tag(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
state.set_container_config_tag('new_tag')
config = state.get_container_config()
assert config['container_tag'] == 'new_tag'
def test_get_build_type_vmconfig_entries_for_simple_disk(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxSimpleFlavour'], 'oem')
assert state.get_build_type_vmconfig_entries() == [
'numvcpus = "4"', 'cpuid.coresPerSocket = "2"'
]
def test_build_type_not_found_no_default_type(self):
description = XMLDescription('../data/example_no_default_type.xml')
xml_data = description.load()
with raises(KiwiTypeNotFound):
XMLState(xml_data, ['minimal'])
def test_get_oemconfig_swap_mbytes_default(self):
description = XMLDescription('../data/example_btrfs_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_oemconfig_swap_mbytes() == 128
def test_appx_invalid_id(self):
xml_state = XMLState(self.description.load(), ['wsl_id'], 'appx')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.check_appx_naming_conventions_valid()
class TestXMLState(object):
@patch('platform.machine')
def setup(self, mock_machine):
mock_machine.return_value = 'x86_64'
description = XMLDescription(
'../data/example_config.xml'
)
self.state = XMLState(
description.load()
)
boot_description = XMLDescription(
'../data/isoboot/example-distribution/config.xml'
)
self.boot_state = XMLState(
boot_description.load()
)
def test_build_type_primary_selected(self):
assert self.state.get_build_type_name() == 'oem'
def test_build_type_first_selected(self):
self.state.xml_data.get_preferences()[1].get_type()[0].set_primary(
False
)
assert self.state.get_build_type_name() == 'oem'
def test_get_package_manager(self):
assert self.state.get_package_manager() == 'zypper'
def test_get_image_version(self):
assert self.state.get_image_version() == '1.13.2'
def test_get_bootstrap_packages(self):
assert self.state.get_bootstrap_packages() == [
'filesystem'
]
def test_get_system_packages(self):
assert self.state.get_system_packages() == [
'gfxboot-branding-openSUSE',
'grub2-branding-openSUSE',
'ifplugd',
'iputils',
'kernel-default',
'openssh',
'plymouth-branding-openSUSE',
'vim'
]
def test_get_system_collections(self):
assert self.state.get_system_collections() == [
'base'
]
def test_get_system_products(self):
assert self.state.get_system_products() == [
'openSUSE'
]
def test_get_system_archives(self):
assert self.state.get_system_archives() == [
'image.tgz'
]
def test_get_system_collection_type(self):
assert self.state.get_system_collection_type() == 'plusRecommended'
def test_get_bootstrap_collections(self):
assert self.state.get_bootstrap_collections() == [
'bootstrap-collection'
]
def test_get_bootstrap_products(self):
assert self.state.get_bootstrap_products() == ['kiwi']
def test_get_bootstrap_archives(self):
assert self.state.get_bootstrap_archives() == ['bootstrap.tgz']
def test_get_bootstrap_collection_type(self):
assert self.state.get_bootstrap_collection_type() == 'onlyRequired'
def test_translate_obs_to_ibs_repositories(self):
self.state.translate_obs_to_ibs_repositories()
source_path = self.state.xml_data.get_repository()[1].get_source()
assert source_path.get_path() == \
'ibs://Devel:PubCloud:AmazonEC2/SLE_12_GA'
def test_translate_obs_to_suse_repositories(self):
self.state.translate_obs_to_suse_repositories()
source_path = self.state.xml_data.get_repository()[1].get_source()
assert source_path.get_path() == \
'suse://Devel:PubCloud:AmazonEC2/SLE_12_GA'
def test_set_repository(self):
self.state.set_repository('repo', 'type', 'alias', 1)
assert self.state.xml_data.get_repository()[0].get_source().get_path() \
== 'repo'
assert self.state.xml_data.get_repository()[0].get_type() == 'type'
assert self.state.xml_data.get_repository()[0].get_alias() == 'alias'
assert self.state.xml_data.get_repository()[0].get_priority() == 1
def test_add_repository(self):
self.state.add_repository('repo', 'type', 'alias', 1)
assert self.state.xml_data.get_repository()[2].get_source().get_path() \
== 'repo'
assert self.state.xml_data.get_repository()[2].get_type() == 'type'
assert self.state.xml_data.get_repository()[2].get_alias() == 'alias'
assert self.state.xml_data.get_repository()[2].get_priority() == 1
def test_get_to_become_deleted_packages(self):
assert self.state.get_to_become_deleted_packages() == [
'kernel-debug'
]
def test_get_build_type_system_disk_section(self):
assert self.state.get_build_type_system_disk_section().get_name() == \
'mydisk'
def test_get_build_type_vmdisk_section(self):
assert self.state.get_build_type_vmdisk_section().get_id() == 0
def test_get_volume_management(self):
assert self.state.get_volume_management() == 'lvm'
def test_get_volume_management_none(self):
assert self.boot_state.get_volume_management() is None
def test_get_volume_management_btrfs(self):
description = XMLDescription('../data/example_btrfs_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'btrfs'
def test_get_volume_management_lvm_prefer(self):
description = XMLDescription('../data/example_lvm_preferred_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'lvm'
def test_get_volume_management_lvm_default(self):
description = XMLDescription('../data/example_lvm_default_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'lvm'
def test_build_type_explicitly_selected(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'vmx')
assert state.get_build_type_name() == 'vmx'
@raises(KiwiTypeNotFound)
def test_build_type_not_found(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
XMLState(xml_data, ['vmxFlavour'], 'foo')
@raises(KiwiProfileNotFound)
def test_profile_not_found(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
XMLState(xml_data, ['foo'])
def test_get_volumes(self):
description = XMLDescription('../data/example_lvm_default_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple(
'volume_type', [
'name',
'size',
'realpath',
'mountpoint',
'fullsize'
]
)
assert state.get_volumes() == [
volume_type(
name='LVusr_lib', size='size:1024',
realpath='usr/lib',
mountpoint=None, fullsize=False
),
volume_type(
name='LVRoot', size='freespace:500',
realpath='/',
mountpoint=None, fullsize=False
),
volume_type(
name='etc_volume', size='freespace:30',
realpath='etc',
mountpoint='LVetc', fullsize=False
),
volume_type(
name='bin_volume', size=None,
realpath='/usr/bin',
mountpoint='LVusr_bin', fullsize=True
)
]
def test_get_volumes_no_explicit_root_setup(self):
description = XMLDescription('../data/example_lvm_no_root_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple(
'volume_type', [
'name',
'size',
'realpath',
'mountpoint',
'fullsize'
]
)
assert state.get_volumes() == [
volume_type(
name='LVRoot', size=None, realpath='/',
mountpoint=None, fullsize=True
)
]
def test_get_volumes_no_explicit_root_setup_other_fullsize_volume(self):
description = XMLDescription(
'../data/example_lvm_no_root_full_usr_config.xml'
)
xml_data = description.load()
state = XMLState(xml_data)
volume_type = namedtuple(
'volume_type', [
'name',
'size',
'realpath',
'mountpoint',
'fullsize'
]
)
assert state.get_volumes() == [
volume_type(
name='LVusr', size=None, realpath='usr',
mountpoint=None, fullsize=True
),
volume_type(
name='LVRoot', size='freespace:30', realpath='/',
mountpoint=None, fullsize=False
)
]
@raises(KiwiInvalidVolumeName)
def test_get_volumes_invalid_name(self):
description = XMLDescription('../data/example_lvm_invalid_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['invalid_volume_a'])
state.get_volumes()
@raises(KiwiInvalidVolumeName)
def test_get_volumes_invalid_mountpoint(self):
description = XMLDescription('../data/example_lvm_invalid_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['invalid_volume_b'])
state.get_volumes()
@raises(KiwiInvalidVolumeName)
def test_get_volumes_invalid_name_for_shell(self):
description = XMLDescription('../data/example_lvm_invalid_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['invalid_volume_c'])
state.get_volumes()
@patch('kiwi.xml_state.XMLState.get_build_type_system_disk_section')
def test_get_empty_volumes(self, mock_system_disk):
mock_system_disk.return_value = None
assert self.state.get_volumes() == []
def test_get_strip_files_to_delete(self):
assert self.state.get_strip_files_to_delete() == ['del-a', 'del-b']
def test_get_strip_tools_to_keep(self):
assert self.state.get_strip_tools_to_keep() == ['tool-a', 'tool-b']
def test_get_strip_libraries_to_keep(self):
assert self.state.get_strip_libraries_to_keep() == ['lib-a', 'lib-b']
def test_get_build_type_machine_section(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
state = XMLState(xml_data, None, 'vmx')
assert state.get_build_type_machine_section().get_guestOS() == 'suse'
def test_get_build_type_pxedeploy_section(self):
description = XMLDescription('../data/example_pxe_config.xml')
xml_data = description.load()
state = XMLState(xml_data, None, 'pxe')
assert state.get_build_type_pxedeploy_section().get_server() == \
'192.168.100.2'
def test_get_drivers_list(self):
assert self.state.get_drivers_list() == \
['crypto/*', 'drivers/acpi/*', 'bar']
def test_get_build_type_oemconfig_section(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
state = XMLState(xml_data, None, 'oem')
assert state.get_build_type_oemconfig_section().get_oem_swap()[0] ==\
'true'
def test_get_users_sections(self):
assert self.state.get_users_sections()[0].get_user()[0].get_name() == \
'root'
def test_get_users(self):
assert self.state.get_users()[0].user_sections[0].get_name() == \
'root'
def test_copy_displayname(self):
self.state.copy_displayname(self.boot_state)
assert self.boot_state.xml_data.get_displayname() == 'Bob'
def test_copy_drivers_sections(self):
self.state.copy_drivers_sections(self.boot_state)
assert 'bar' in self.boot_state.get_drivers_list()
def test_copy_systemdisk_section(self):
self.state.copy_systemdisk_section(self.boot_state)
systemdisk = self.boot_state.get_build_type_system_disk_section()
assert systemdisk.get_name() == 'mydisk'
def test_copy_strip_sections(self):
self.state.copy_strip_sections(self.boot_state)
assert 'del-a' in self.boot_state.get_strip_files_to_delete()
def test_copy_machine_section(self):
self.state.copy_machine_section(self.boot_state)
machine = self.boot_state.get_build_type_machine_section()
assert machine.get_memory() == 512
def test_copy_oemconfig_section(self):
self.state.copy_oemconfig_section(self.boot_state)
oemconfig = self.boot_state.get_build_type_oemconfig_section()
assert oemconfig.get_oem_systemsize()[0] == 2048
def test_copy_repository_sections(self):
self.state.copy_repository_sections(self.boot_state, True)
repository = self.boot_state.get_repository_sections()[0]
assert repository.get_source().get_path() == 'iso:///image/CDs/dvd.iso'
def test_copy_preferences_subsections(self):
self.state.copy_preferences_subsections(
['bootsplash_theme'], self.boot_state
)
preferences = self.boot_state.get_preferences_sections()[0]
assert preferences.get_bootsplash_theme()[0] == 'openSUSE'
def test_copy_build_type_attributes(self):
self.state.copy_build_type_attributes(
['firmware'], self.boot_state
)
assert self.boot_state.build_type.get_firmware() == 'efi'
def test_copy_bootincluded_packages(self):
self.state.copy_bootincluded_packages(self.boot_state)
bootstrap_packages = self.boot_state.get_bootstrap_packages()
assert 'plymouth-branding-openSUSE' in bootstrap_packages
assert 'grub2-branding-openSUSE' in bootstrap_packages
assert 'gfxboot-branding-openSUSE' in bootstrap_packages
to_delete_packages = self.boot_state.get_to_become_deleted_packages()
assert 'gfxboot-branding-openSUSE' not in to_delete_packages
def test_copy_bootincluded_archives(self):
self.state.copy_bootincluded_archives(self.boot_state)
bootstrap_archives = self.boot_state.get_bootstrap_archives()
assert 'image.tgz' in bootstrap_archives
def test_copy_bootdelete_packages(self):
self.state.copy_bootdelete_packages(self.boot_state)
to_delete_packages = self.boot_state.get_to_become_deleted_packages()
assert 'vim' in to_delete_packages
def test_build_type_size(self):
result = self.state.get_build_type_size()
assert result.mbytes == 1024
assert result.additive
def test_get_volume_group_name(self):
assert self.state.get_volume_group_name() == 'mydisk'
def test_get_volume_group_name_default(self):
assert self.boot_state.get_volume_group_name() == 'systemVG'
def test_get_distribution_name_from_boot_attribute(self):
assert self.state.get_distribution_name_from_boot_attribute() == \
'distribution'
@raises(KiwiDistributionNameError)
@patch('kiwi.xml_parse.type_.get_boot')
def test_get_distribution_name_from_boot_attribute_no_boot(self, mock_boot):
mock_boot.return_value = None
self.state.get_distribution_name_from_boot_attribute()
@raises(KiwiDistributionNameError)
@patch('kiwi.xml_parse.type_.get_boot')
def test_get_distribution_name_from_boot_attribute_invalid_boot(
self, mock_boot
):
mock_boot.return_value = 'invalid'
self.state.get_distribution_name_from_boot_attribute()
def test_check_preferences_data_no_packagemanager(self):
xml_state = XMLState(self.description.load(), ['xenDom0Flavour'],
'oem')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.check_minimal_required_preferences()
def test_get_volume_management_lvm_default(self):
description = XMLDescription('../data/example_lvm_default_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_volume_management() == 'lvm'
class BootImageBase(object):
"""
**Base class for boot image(initrd) task**
:param object xml_state: Instance of :class:`XMLState`
:param string target_dir: target dir to store the initrd
:param string root_dir: system image root directory
:param list signing_keys: list of package signing keys
:param dict custom_args: Custom processing arguments defined as hash keys
"""
def __init__(
self, xml_state, target_dir, root_dir=None,
signing_keys=None, custom_args=None
):
self.xml_state = xml_state
self.target_dir = target_dir
self.initrd_filename = None
self.boot_xml_state = None
self.setup = None
self.temp_directories = []
self.call_destructor = True
self.signing_keys = signing_keys
self.boot_root_directory = root_dir
if not os.path.exists(target_dir):
raise KiwiTargetDirectoryNotFound(
'target directory %s not found' % target_dir
)
self.initrd_base_name = ''.join(
[
self.xml_state.xml_data.get_name(),
'.' + platform.machine(),
'-' + self.xml_state.get_image_version(),
'.initrd'
]
)
self.post_init()
def post_init(self):
"""
Post initialization method
Implementation in specialized boot image class
"""
pass
def include_file(self, filename):
"""
Include file to boot image
For kiwi boot images this is done by adding package or
archive definitions with the bootinclude attribute. Thus
for kiwi boot images the method is a noop
:param string filename: file path name
"""
pass
def dump(self, filename):
"""
Pickle dump this instance to a file. If the object dump
is requested the destructor code will also be disabled
in order to preserve the generated data
:param string filename: file path name
"""
try:
with open(filename, 'wb') as boot_image:
pickle.dump(self, boot_image)
self.disable_cleanup()
except Exception as e:
raise KiwiBootImageDumpError(
'Failed to pickle dump boot image: %s' % format(e)
)
def disable_cleanup(self):
"""
Deactivate cleanup(deletion) of boot root directory
"""
self.call_destructor = False
def enable_cleanup(self):
"""
Activate cleanup(deletion) of boot root directory
"""
self.call_destructor = True
def get_boot_names(self):
"""
Provides kernel and initrd names for this boot image
Implementation in specialized boot image class
"""
raise NotImplementedError
def prepare(self):
"""
Prepare new root system to create initrd from. Implementation
is only needed if there is no other root system available
Implementation in specialized boot image class
"""
raise NotImplementedError
def create_initrd(self, mbrid=None, basename=None):
"""
Implements creation of the initrd
:param object mbrid: instance of ImageIdentifier
:param string basename: base initrd file name
Implementation in specialized boot image class
"""
raise NotImplementedError
def is_prepared(self):
"""
Check if initrd system is prepared.
:return: True or False
:rtype: bool
"""
return os.listdir(self.boot_root_directory)
def load_boot_xml_description(self):
"""
Load the boot image description referenced by the system image
description boot attribute
"""
log.info('Loading Boot XML description')
boot_description_directory = self.get_boot_description_directory()
if not boot_description_directory:
raise KiwiConfigFileNotFound(
'no boot reference specified in XML description'
)
boot_config_file = boot_description_directory + '/config.xml'
if not os.path.exists(boot_config_file):
raise KiwiConfigFileNotFound(
'no Boot XML description found in %s' %
boot_description_directory
)
boot_description = XMLDescription(
description=boot_config_file,
derived_from=self.xml_state.xml_data.description_dir
)
boot_image_profile = self.xml_state.build_type.get_bootprofile()
if not boot_image_profile:
boot_image_profile = 'default'
boot_kernel_profile = self.xml_state.build_type.get_bootkernel()
if not boot_kernel_profile:
boot_kernel_profile = 'std'
self.boot_xml_state = XMLState(
boot_description.load(), [boot_image_profile, boot_kernel_profile]
)
log.info('--> loaded %s', boot_config_file)
if self.boot_xml_state.build_type:
log.info(
'--> Selected build type: %s',
self.boot_xml_state.get_build_type_name()
)
if self.boot_xml_state.profiles:
log.info(
'--> Selected boot profiles: image: %s, kernel: %s',
boot_image_profile, boot_kernel_profile
)
def import_system_description_elements(self):
"""
Copy information from the system image relevant to create the
boot image to the boot image state XML description
"""
self.xml_state.copy_displayname(
self.boot_xml_state
)
self.xml_state.copy_name(
self.boot_xml_state
)
self.xml_state.copy_repository_sections(
target_state=self.boot_xml_state,
wipe=True
)
self.xml_state.copy_drivers_sections(
self.boot_xml_state
)
strip_description = XMLDescription(
Defaults.get_boot_image_strip_file()
)
strip_xml_state = XMLState(strip_description.load())
strip_xml_state.copy_strip_sections(
self.boot_xml_state
)
self.xml_state.copy_strip_sections(
self.boot_xml_state
)
preferences_subsection_names = [
'bootloader_theme',
'bootsplash_theme',
'locale',
'packagemanager',
'rpm_check_signatures',
'rpm_excludedocs',
'showlicense'
]
self.xml_state.copy_preferences_subsections(
preferences_subsection_names, self.boot_xml_state
)
self.xml_state.copy_bootincluded_packages(
self.boot_xml_state
)
self.xml_state.copy_bootincluded_archives(
self.boot_xml_state
)
self.xml_state.copy_bootdelete_packages(
self.boot_xml_state
)
type_attributes = [
'bootkernel',
'bootloader',
'bootloader_console',
'bootprofile',
'boottimeout',
'btrfs_root_is_snapshot',
'gpt_hybrid_mbr',
'devicepersistency',
'filesystem',
'firmware',
'fsmountoptions',
'hybridpersistent',
'hybridpersistent_filesystem',
'initrd_system',
'installboot',
'installprovidefailsafe',
'kernelcmdline',
'ramonly',
'target_removable',
'vga',
'wwid_wait_timeout'
]
self.xml_state.copy_build_type_attributes(
type_attributes, self.boot_xml_state
)
self.xml_state.copy_systemdisk_section(
self.boot_xml_state
)
self.xml_state.copy_machine_section(
self.boot_xml_state
)
self.xml_state.copy_oemconfig_section(
self.boot_xml_state
)
def get_boot_description_directory(self):
"""
Provide path to the boot image XML description
:return: path name
:rtype: str
"""
boot_description = self.xml_state.build_type.get_boot()
if boot_description:
if not boot_description[0] == '/':
boot_description = \
Defaults.get_boot_image_description_path() + '/' + \
boot_description
return boot_description
def __del__(self):
if self.call_destructor:
log.info('Cleaning up %s instance', type(self).__name__)
for directory in self.temp_directories:
if directory and os.path.exists(directory):
Path.wipe(directory)
def test_add_container_label_without_contianerconfig(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['xenDom0Flavour'], 'docker')
state.add_container_config_label('somelabel', 'newlabelvalue')
config = state.get_container_config()
assert config['labels'] == {'somelabel': 'newlabelvalue'}
def test_check_preferences_data_no_version(self):
xml_state = XMLState(self.description.load(), ['docker'], 'docker')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.check_minimal_required_preferences()
def test_get_oemconfig_swap_name(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
assert state.get_oemconfig_swap_name() == 'LVSwap'
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_oemconfig_swap_name() == 'swap'
def test_build_type_explicitly_selected(self):
description = XMLDescription('../data/example_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['vmxFlavour'], 'vmx')
assert state.get_build_type_name() == 'vmx'
def test_get_oemconfig_swap_mbytes(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['containerFlavour'], 'docker')
assert state.get_oemconfig_swap_mbytes() is None
state = XMLState(xml_data, ['vmxFlavour'], 'oem')
assert state.get_oemconfig_swap_mbytes() == 42
def test_check_dracut_module_for_oem_install_in_package_list(self):
xml_state = XMLState(self.description.load(), ['vmxFlavour'], 'oem')
runtime_checker = RuntimeChecker(xml_state)
with raises(KiwiRuntimeError):
runtime_checker.\
check_dracut_module_for_oem_install_in_package_list()
def test_get_build_type_oemconfig_section(self):
xml_data = self.description.load()
state = XMLState(xml_data, None, 'oem')
assert state.get_build_type_oemconfig_section().get_oem_swap()[0] is \
True
def test_get_volumes_invalid_name_for_shell(self):
description = XMLDescription('../data/example_lvm_invalid_config.xml')
xml_data = description.load()
state = XMLState(xml_data, ['invalid_volume_c'])
state.get_volumes()
def test_get_build_type_machine_section(self):
xml_data = self.description.load()
state = XMLState(xml_data, ['vmxSimpleFlavour'], 'oem')
assert state.get_build_type_machine_section().get_guestOS() == 'suse'
def test_get_build_type_pxedeploy_section(self):
description = XMLDescription('../data/example_pxe_config.xml')
xml_data = description.load()
state = XMLState(xml_data, None, 'pxe')
assert state.get_build_type_pxedeploy_section().get_server() == \
'192.168.100.2'
def test_profile_requires(self):
xml_data = self.description.load()
xml_state = XMLState(xml_data, ['composedProfile'])
assert xml_state.profiles == [
'composedProfile', 'vmxSimpleFlavour', 'xenDomUFlavour'
]
def setup(self):
self.description = XMLDescription(
'../data/example_runtime_checker_config.xml')
self.xml_state = XMLState(self.description.load())
self.runtime_checker = RuntimeChecker(self.xml_state)
def test_get_build_type_vmconfig_entries_no_machine_section(self):
description = XMLDescription('../data/example_disk_config.xml')
xml_data = description.load()
state = XMLState(xml_data)
assert state.get_build_type_vmconfig_entries() == []
