def test_prime_without_architectures_records_current_arch(self):
"""Test the recorded manifest for a basic snap
This snap doesn't have stage or build packages and it is not declared
that it works on all architectures, which makes it specific to the
current architecture.
"""
self.run_snapcraft('prime', project_dir='basic-without-arch')
recorded_yaml_path = os.path.join(
self.prime_dir, 'snap', 'manifest.yaml')
with open(recorded_yaml_path) as recorded_yaml_file:
recorded_yaml = yaml.load(recorded_yaml_file)
self.assertThat(
recorded_yaml['architectures'],
Equals([snapcraft.ProjectOptions().deb_arch]))
def setUp(self):
super().setUp()
patcher = mock.patch.dict(os.environ, {})
self.env_mock = patcher.start()
self.addCleanup(patcher.stop)
class Options:
makefile = None
make_parameters = []
rust_features = []
rust_revision = ''
rust_channel = ''
source_subdir = ''
self.options = Options()
self.project_options = snapcraft.ProjectOptions()
def test_kernel_image_target_non_existent(self):
class Options:
build_parameters = []
kconfigfile = None
kdefconfig = []
kconfigs = []
kernel_with_firmware = True
kernel_initrd_modules = []
kernel_initrd_firmware = []
kernel_device_trees = []
kernel_initrd_compression = 'gz'
project_options = snapcraft.ProjectOptions(target_deb_arch='arm64')
plugin = kernel.KernelPlugin('test-part', self.options,
project_options)
self.assertEqual(plugin.make_targets, ['bzImage', 'modules'])
def setUp(self):
super().setUp()
class Options:
build_parameters = []
kconfigfile = None
kconfigflavour = None
kdefconfig = []
kconfigs = []
kernel_image_target = "bzImage"
kernel_with_firmware = True
kernel_initrd_modules = []
kernel_initrd_firmware = []
kernel_device_trees = []
kernel_initrd_compression = "gz"
build_attributes = []
self.options = Options()
self.project_options = snapcraft.ProjectOptions()
patcher = mock.patch("subprocess.check_call")
self.check_call_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch.object(kernel.KernelPlugin, "run")
self.run_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch.object(kernel.KernelPlugin, "run_output")
self.run_output_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch("snapcraft.BasePlugin.build")
self.base_build_mock = patcher.start()
self.addCleanup(patcher.stop)
@contextlib.contextmanager
def tempdir():
self.tempdir = "temporary-directory"
os.mkdir(self.tempdir)
yield self.tempdir
patcher = mock.patch("tempfile.TemporaryDirectory")
self.tempdir_mock = patcher.start()
self.tempdir_mock.side_effect = tempdir
self.addCleanup(patcher.stop)
def test_enable_cross_compilation(self):
project_options = snapcraft.ProjectOptions(target_deb_arch="arm64")
plugin = kernel.KernelPlugin("test-part", self.options,
project_options)
plugin.enable_cross_compilation()
self.assertThat(
plugin.make_cmd,
Equals([
"make",
"-j2",
"ARCH=arm64",
"CROSS_COMPILE=aarch64-linux-gnu-",
"PATH={}:/usr/{}/bin".format(os.environ.copy().get("PATH", ""),
"aarch64-linux-gnu"),
]),
)
def test_get_package_trusted_parts_already_imported(
self, mock_apt_pkg, mock_fetch_binary):
fake_package_path = os.path.join(self.path, "fake-package.deb")
open(fake_package_path, "w").close()
mock_fetch_binary.return_value = fake_package_path
self.mock_cache().is_virtual_package.return_value = False
def _fake_find_file(key: str):
if key == "Dir::Etc::TrustedParts":
return os.path.join(ubuntu._cache.base_dir, "trusted")
else:
return DEFAULT
mock_apt_pkg.config.find_file.side_effect = _fake_find_file
project_options = snapcraft.ProjectOptions()
ubuntu = repo.Ubuntu(self.tempdir, project_options=project_options)
ubuntu.get(["fake-package"])
mock_apt_pkg.assert_has_calls([
call.config.set("Apt::Install-Recommends", "False"),
call.config.set("Acquire::AllowInsecureRepositories", "False"),
call.config.find_file("Dir::Etc::Trusted"),
call.config.set("Dir::Etc::Trusted", ANY),
call.config.find_file("Dir::Etc::TrustedParts"),
call.config.clear("APT::Update::Post-Invoke-Success"),
])
self.mock_cache.assert_has_calls([
call(memonly=True, rootdir=ANY),
call().update(fetch_progress=ANY, sources_list=ANY),
call().open(),
])
# __getitem__ is tricky
self.assertThat(
self.mock_cache.return_value.__getitem__.call_args_list,
Contains(call("fake-package")),
)
# Verify that the package was actually fetched and copied into the
# requested location.
self.assertThat(
os.path.join(self.tempdir, "download", "fake-package.deb"),
FileExists())
def load_part(self,
part_name,
plugin_name=None,
part_properties=None,
project_options=None,
stage_packages_repo=None,
confinement='strict'):
if not plugin_name:
plugin_name = 'nil'
properties = {'plugin': plugin_name}
if part_properties:
properties.update(part_properties)
if not project_options:
project_options = snapcraft.ProjectOptions()
validator = snapcraft.internal.project_loader.Validator()
schema = validator.part_schema
definitions_schema = validator.definitions_schema
plugin = snapcraft.internal.pluginhandler.load_plugin(
part_name=part_name,
plugin_name=plugin_name,
properties=properties,
project_options=project_options,
part_schema=schema,
definitions_schema=definitions_schema)
if not stage_packages_repo:
stage_packages_repo = mock.Mock()
grammar_processor = grammar_processing.PartGrammarProcessor(
plugin=plugin,
properties=properties,
project_options=project_options,
repo=stage_packages_repo)
return snapcraft.internal.pluginhandler.PluginHandler(
plugin=plugin,
part_properties=properties,
project_options=project_options,
part_schema=schema,
definitions_schema=definitions_schema,
grammar_processor=grammar_processor,
stage_packages_repo=stage_packages_repo,
snap_base_path='/snap/fake-name/current',
confinement=confinement,
soname_cache=elf.SonameCache())
def setUp(self):
super().setUp()
class Options:
configflags = []
install_via = 'destdir'
disable_parallel = False
makefile = None
make_parameters = []
make_install_var = 'DESTDIR'
artifacts = []
self.options = Options()
self.project_options = snapcraft.ProjectOptions()
patcher = mock.patch('snapcraft.repo.Ubuntu')
self.ubuntu_mock = patcher.start()
self.addCleanup(patcher.stop)
def setUp(self):
super().setUp()
class Options:
gradle_options = []
gradle_output_dir = 'build/libs'
self.options = Options()
self.project_options = snapcraft.ProjectOptions()
patcher = mock.patch('snapcraft.repo.Ubuntu')
self.ubuntu_mock = patcher.start()
self.addCleanup(patcher.stop)
# unset http and https proxies.
self.useFixture(fixtures.EnvironmentVariable('http_proxy', None))
self.useFixture(fixtures.EnvironmentVariable('https_proxy', None))
def setUp(self):
super().setUp()
self.project = snapcraft.ProjectOptions()
self.rosdep = rosdep.Rosdep(ros_distro='kinetic',
ros_package_path='package_path',
rosdep_path='rosdep_path',
ubuntu_distro='xenial',
ubuntu_sources='sources',
project=self.project)
patcher = mock.patch('snapcraft.repo.Ubuntu')
self.ubuntu_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch('subprocess.check_output')
self.check_output_mock = patcher.start()
self.addCleanup(patcher.stop)
def test_config_adds_extra_build_tools_when_cross_compiling(self):
with unittest.mock.patch('platform.machine') as machine_mock:
machine_mock.return_value = 'x86_64'
project_options = snapcraft.ProjectOptions(target_deb_arch='armhf')
yaml = """name: test
version: "1"
summary: test
description: test
parts:
part1:
plugin: nil
"""
self.make_snapcraft_yaml(yaml)
config = internal_yaml.Config(project_options)
self.assertEqual(config.build_tools, ['gcc-arm-linux-gnueabihf'])
def test(self, to_arch, body, else_bodies, target_arch,
expected_exception):
with pytest.raises(grammar.errors.ToStatementSyntaxError) as error:
processor = grammar.GrammarProcessor(
None,
snapcraft.ProjectOptions(target_deb_arch=target_arch),
lambda x: True,
)
statement = to.ToStatement(to=to_arch,
body=body,
processor=processor)
for else_body in else_bodies:
statement.add_else(else_body)
statement.process()
assert re.match(expected_exception, str(error.value))
def setUp(self):
super().setUp()
self.useFixture(fixture_setup.CleanEnvironment())
self.project_options = snapcraft.ProjectOptions()
patcher = mock.patch('snapcraft.internal.common.run')
self.run_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch('snapcraft.internal.common.run_output')
self.run_output_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch('sys.stdout')
patcher.start()
self.addCleanup(patcher.stop)
def loadplugin(part_name,
plugin_name=None,
part_properties=None,
project_options=None):
if not plugin_name:
plugin_name = 'nil'
properties = {'plugin': plugin_name}
if part_properties:
properties.update(part_properties)
if not project_options:
project_options = snapcraft.ProjectOptions()
schema = project_loader.Validator().part_schema
return pluginhandler.load_plugin(part_name=part_name,
plugin_name=plugin_name,
part_properties=properties,
project_options=project_options,
part_schema=schema)
def test_kernel_image_target_non_existent(self):
class Options:
build_parameters = []
kconfigfile = None
kdefconfig = []
kconfigs = []
kernel_with_firmware = True
kernel_initrd_modules = []
kernel_initrd_firmware = []
kernel_device_trees = []
kernel_initrd_compression = "gz"
project_options = snapcraft.ProjectOptions(target_deb_arch="arm64")
plugin = kernel.KernelPlugin("test-part", self.options,
project_options)
self.assertThat(plugin.make_targets,
Equals(["bzImage", "modules", "dtbs"]))
def test_on_statement_invalid_grammar(self):
with testtools.ExpectedException(self.expected_exception,
self.expected_message):
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(target_deb_arch="armhf"),
self.checker)
statements = [
on.OnStatement(on=self.on, body=None, processor=processor),
to.ToStatement(to=self.to, body=None, processor=processor),
]
statement = compound.CompoundStatement(statements=statements,
body=self.body,
processor=processor)
for else_body in self.else_bodies:
statement.add_else(else_body)
statement.process()
def test_else_fail(self, platform_machine_mock,
platform_architecture_mock):
platform_machine_mock.return_value = "x86_64"
platform_architecture_mock.return_value = ("64bit", "ELF")
processor = grammar.GrammarProcessor(None, snapcraft.ProjectOptions(),
self.checker)
statement = on.OnStatement(on="on i386",
body=["foo"],
processor=processor)
statement.add_else(None)
with testtools.ExpectedException(
grammar.errors.UnsatisfiedStatementError,
"Unable to satisfy 'on i386', failure forced",
):
statement.process()
def setUp(self):
super().setUp()
self.project = snapcraft.ProjectOptions()
self.rosdep = rosdep.Rosdep(
ros_distro="kinetic",
ros_package_path="package_path",
rosdep_path="rosdep_path",
ubuntu_distro="xenial",
)
patcher = mock.patch("snapcraft.repo.Ubuntu")
self.ubuntu_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch("subprocess.check_output")
self.check_output_mock = patcher.start()
self.addCleanup(patcher.stop)
def __init__(self, project_options=None):
if project_options is None:
project_options = snapcraft.ProjectOptions()
self.build_snaps = set()
self.build_tools = []
self._project_options = project_options
self.snapcraft_yaml_path = get_snapcraft_yaml()
snapcraft_yaml = _snapcraft_yaml_load(self.snapcraft_yaml_path)
self._validator = Validator(snapcraft_yaml)
self._validator.validate()
snapcraft_yaml = self._process_remote_parts(snapcraft_yaml)
snapcraft_yaml = self._expand_filesets(snapcraft_yaml)
# both confinement type and build quality are optionals
_ensure_confinement_default(snapcraft_yaml, self._validator.schema)
_ensure_grade_default(snapcraft_yaml, self._validator.schema)
self.data = self._expand_env(snapcraft_yaml)
self._ensure_no_duplicate_app_aliases()
grammar_processor = grammar_processing.GlobalGrammarProcessor(
properties=self.data, project_options=project_options)
self.build_tools = grammar_processor.get_build_packages()
self.build_tools |= set(project_options.additional_build_packages)
# This is required for patching to work correctly
if _requires_patchelf_snap(self.data['confinement']):
# TODO use stable once possible
self.build_snaps.add('patchelf/latest/edge')
self.parts = PartsConfig(parts=self.data,
project_options=self._project_options,
validator=self._validator,
build_snaps=self.build_snaps,
build_tools=self.build_tools,
snapcraft_yaml=self.snapcraft_yaml_path)
if 'architectures' not in self.data:
self.data['architectures'] = [self._project_options.deb_arch]
def test_config_with_wiki_part_after(self, mock_get_part, mock_load):
self.make_snapcraft_yaml("""name: test
version: "1"
summary: test
description: test
confinement: strict
parts:
part1:
after:
- part2wiki
plugin: go
stage-packages: [fswebcam]
""")
def load_effect(*args, **kwargs):
mock_part = unittest.mock.Mock()
mock_part.code.build_packages = []
mock_part.deps = []
mock_part.name = args[0]
return mock_part
mock_load.side_effect = load_effect
mock_get_part.return_value = {
'plugin': 'go',
'source': 'http://somesource'
}
project_options = snapcraft.ProjectOptions()
internal_yaml.Config(project_options)
call1 = unittest.mock.call('part1', 'go', {
'stage': [],
'snap': [],
'stage-packages': ['fswebcam']
}, project_options, self.part_schema)
call2 = unittest.mock.call('part2wiki', 'go',
{'source': 'http://somesource'},
project_options, self.part_schema)
mock_load.assert_has_calls([call1, call2])
self.assertTrue(mock_get_part.called)
def setUp(self):
super().setUp()
dirs.setup_dirs()
patcher = unittest.mock.patch(
'snapcraft.internal.project_loader.get_snapcraft_yaml')
self.mock_get_yaml = patcher.start()
self.mock_get_yaml.return_value = os.path.join('snap',
'snapcraft.yaml')
self.addCleanup(patcher.stop)
patcher = unittest.mock.patch(
'snapcraft.internal.project_loader._parts_config.PartsConfig'
'.load_part')
self.mock_plugin_loader = patcher.start()
self.addCleanup(patcher.stop)
self.part_schema = project_loader.Validator().part_schema
self.deb_arch = snapcraft.ProjectOptions().deb_arch
def setUp(self):
super().setUp()
self.project_options = snapcraft.ProjectOptions()
patcher = mock.patch('snapcraft.internal.common.run')
self.run_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch('sys.stdout')
patcher.start()
self.addCleanup(patcher.stop)
class Options:
options = []
qt_version = 'qt5'
project_files = []
self.options = Options()
def test_opencv(self):
snap_path = self.build_snap(self.snap_content_dir)
bin_path = os.path.join(os.path.dirname(snap_path), 'prime', 'bin',
'example')
self.assertThat(bin_path, FileExists())
interpreter = subprocess.check_output(
['patchelf', '--print-interpreter', bin_path]).decode()
expected_interpreter = r'^/snap/core/current/.*'
self.assertThat(interpreter, MatchesRegex(expected_interpreter))
arch_triplet = snapcraft.ProjectOptions().arch_triplet
# test $ORIGIN in action
rpath = subprocess.check_output(
['patchelf', '--print-rpath', bin_path]).decode()
expected_rpath = '$ORIGIN/../usr/lib/{}:'.format(arch_triplet)
self.assertThat(rpath, Contains(expected_rpath))
# test $ORIGIN applied
ldd = subprocess.check_output(['ldd', bin_path]).decode()
expected_opencv_path = (
'/prime/bin/../usr/lib/{}/libopencv_core'.format(arch_triplet))
self.assertThat(ldd, Contains(expected_opencv_path))
self.install_snap(snap_path, 'opencv-example', '1.0', classic=True)
if not snaps_tests.config.get('skip-install', False):
output = self.run_command_in_snappy_testbed(
'/snap/bin/opencv-example.example').splitlines()
# Depending on opencv the result is now displayed differently
# so let's do a lazy match.
# On artful you see:
# [ 1, 3;
# 2, 4]
# And on others:
# [1, 3;
# 2, 4]
expected_in_first_line = ['[', '1', ',', '3', ';']
self.assertThat(output[0], ContainsAll(expected_in_first_line))
expected_in_second_line = ['2', ',', '4', ']']
self.assertThat(output[1], ContainsAll(expected_in_second_line))
def setUp(self):
super().setUp()
self.project_options = snapcraft.ProjectOptions()
patcher = mock.patch('snapcraft.internal.common.run')
self.run_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch('snapcraft.sources.Tar')
self.tar_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch('sys.stdout')
patcher.start()
self.addCleanup(patcher.stop)
self.nodejs_url = nodejs.get_nodejs_release(
nodejs._NODEJS_VERSION, self.project_options.deb_arch)
def setUp(self):
super().setUp()
self.project_options = snapcraft.ProjectOptions()
patcher = mock.patch('snapcraft.internal.common.run')
self.run_mock = patcher.start()
self.addCleanup(patcher.stop)
patcher = mock.patch('sys.stdout')
patcher.start()
self.addCleanup(patcher.stop)
class Options:
source = 'src'
go_importpath = 'github.com/foo/bar'
godeps_file = 'dependencies.tsv'
self.options = Options()
def setUp(self):
super().setUp()
self.installdir = os.path.join(os.getcwd(), 'installdir')
os.makedirs(self.installdir)
self.stagedir = os.path.join(os.getcwd(), 'stagedir')
os.makedirs(self.stagedir)
self.bindir = os.path.join(os.getcwd(), 'bin')
os.makedirs(self.bindir)
project_options = snapcraft.ProjectOptions()
env = internal_yaml._create_pkg_config_override(
self.bindir, self.installdir, self.stagedir,
project_options.arch_triplet)
self.assertEqual(env, ['PATH={}:$PATH'.format(self.bindir)])
self.pkg_config_bin = os.path.join(self.bindir, 'pkg-config')
def __init__(self, project_options=None):
if project_options is None:
project_options = snapcraft.ProjectOptions()
self.build_snaps = set()
self.build_tools = []
self._project_options = project_options
self.snapcraft_yaml_path = get_snapcraft_yaml()
snapcraft_yaml = _snapcraft_yaml_load(self.snapcraft_yaml_path)
self._validator = Validator(snapcraft_yaml)
self._validator.validate()
snapcraft_yaml = self._process_remote_parts(snapcraft_yaml)
snapcraft_yaml = self._expand_filesets(snapcraft_yaml)
# both confinement type and build quality are optionals
_ensure_confinement_default(snapcraft_yaml, self._validator.schema)
_ensure_grade_default(snapcraft_yaml, self._validator.schema)
self.data = self._expand_env(snapcraft_yaml)
self._ensure_no_duplicate_app_aliases()
grammar_processor = grammar_processing.GlobalGrammarProcessor(
properties=self.data, project_options=project_options)
self.build_tools = grammar_processor.get_build_packages()
self.build_tools |= set(project_options.additional_build_packages)
# Install patchelf to enable patching in classic
if self.data['confinement'] == 'classic' and not common.is_snap():
self.build_tools.add('patchelf')
self.parts = PartsConfig(parts=self.data,
project_options=self._project_options,
validator=self._validator,
build_snaps=self.build_snaps,
build_tools=self.build_tools,
snapcraft_yaml=self.snapcraft_yaml_path)
if 'architectures' not in self.data:
self.data['architectures'] = [self._project_options.deb_arch]
def test_compound_statement_grammar(self, platform_machine_mock,
platform_architecture_mock):
platform_machine_mock.return_value = self.host_arch
platform_architecture_mock.return_value = ("64bit", "ELF")
processor = grammar.GrammarProcessor(
None, snapcraft.ProjectOptions(target_deb_arch="armhf"),
self.checker)
statements = [
on.OnStatement(on=self.on, body=None, processor=processor),
to.ToStatement(to=self.to, body=None, processor=processor),
]
statement = compound.CompoundStatement(statements=statements,
body=self.body,
processor=processor)
for else_body in self.else_bodies:
statement.add_else(else_body)
self.assertThat(statement.process(), Equals(self.expected_packages))
def test_sources_is_none_uses_default(self, mock_cc):
project_options = snapcraft.ProjectOptions(use_geoip=True)
mock_cc.return_value = 'ar'
self.maxDiff = None
sources_list = repo._format_sources_list('', project_options)
expected_sources_list = \
'''deb http://ar.archive.ubuntu.com/ubuntu/ xenial main restricted
deb http://ar.archive.ubuntu.com/ubuntu/ xenial-updates main restricted
deb http://ar.archive.ubuntu.com/ubuntu/ xenial universe
deb http://ar.archive.ubuntu.com/ubuntu/ xenial-updates universe
deb http://ar.archive.ubuntu.com/ubuntu/ xenial multiverse
deb http://ar.archive.ubuntu.com/ubuntu/ xenial-updates multiverse
deb http://security.ubuntu.com/ubuntu xenial-security main restricted
deb http://security.ubuntu.com/ubuntu xenial-security universe
deb http://security.ubuntu.com/ubuntu xenial-security multiverse
'''
self.assertEqual(sources_list, expected_sources_list)
def test_sources_armhf_trusty(self, mock_cc):
project_options = snapcraft.ProjectOptions(use_geoip=True,
target_deb_arch='armhf')
sources_list = repo._format_sources_list(repo._DEFAULT_SOURCES,
project_options, 'trusty')
expected_sources_list = \
'''deb http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted
deb http://ports.ubuntu.com/ubuntu-ports/ trusty-updates main restricted
deb http://ports.ubuntu.com/ubuntu-ports/ trusty universe
deb http://ports.ubuntu.com/ubuntu-ports/ trusty-updates universe
deb http://ports.ubuntu.com/ubuntu-ports/ trusty multiverse
deb http://ports.ubuntu.com/ubuntu-ports/ trusty-updates multiverse
deb http://ports.ubuntu.com/ubuntu-ports trusty-security main restricted
deb http://ports.ubuntu.com/ubuntu-ports trusty-security universe
deb http://ports.ubuntu.com/ubuntu-ports trusty-security multiverse
'''
self.assertEqual(sources_list, expected_sources_list)
self.assertFalse(mock_cc.called)
