def test_snapd_not_on_host_installs_from_store(self):
self.useFixture(fixture_setup.FakeStore())
snap_injector = SnapInjector(
snap_dir=self.provider._SNAPS_MOUNTPOINT,
registry_filepath=self.registry_filepath,
snap_arch="amd64",
runner=self.provider._run,
snap_dir_mounter=self.provider._mount_snaps_directory,
snap_dir_unmounter=self.provider._unmount_snaps_directory,
file_pusher=self.provider._push_file,
)
snap_injector.add("core")
snap_injector.add("snapcraft")
with patch(
"snapcraft.internal.repo.snaps.SnapPackage.get_local_snap_info",
side_effect=repo.errors.SnapdConnectionError("core", "url"),
):
snap_injector.apply()
self.get_assertion_mock.assert_not_called()
self.provider.run_mock.assert_has_calls([
call(["snap", "set", "core", ANY]),
call(["snap", "watch", "--last=auto-refresh"]),
call(["snap", "install", "--channel", "stable", "core"]),
call([
"snap", "install", "--classic", "--channel", "stable",
"snapcraft"
]),
])
self.provider.mount_mock.assert_not_called()
self.provider.unmount_mock.assert_not_called()
self.provider.push_file_mock.assert_not_called()
self.assertThat(
self.registry_filepath,
FileContains(
dedent("""\
core:
- revision: '10000'
snapcraft:
- revision: '25'
""")),
)
def test_prime_step_records_prime_keyword(self):
self.useFixture(
fixtures.EnvironmentVariable("SNAPCRAFT_BUILD_INFO", "1"))
parts = textwrap.dedent("""\
parts:
test-part:
plugin: nil
{}: [-*]
""")
project_config = self.make_snapcraft_project(parts.format(
self.keyword))
lifecycle.execute(steps.PRIME, project_config)
expected = textwrap.dedent("""\
snapcraft-version: '3.0'
snapcraft-os-release-id: ubuntu
snapcraft-os-release-version-id: '16.04'
name: test
version: 0
summary: test
description: test
confinement: strict
grade: stable
parts:
test-part:
build-packages: []
installed-packages:
- patchelf=0.9
installed-snaps: []
plugin: nil
prime:
- -*
stage: []
stage-packages: []
uname: Linux test uname 4.10 x86_64
architectures:
- {}
build-packages: []
build-snaps: []
""".format(project_config.project.deb_arch))
self.assertThat(
os.path.join(steps.PRIME.name, "snap", "manifest.yaml"),
FileContains(expected),
)
def test_send_and_set_to_always(self):
self.prompt_mock.return_value = self.answer
self.mock_isatty.return_value = self.tty
try:
self.call_handler(RuntimeError("not a SnapcraftError"), True)
except Exception:
self.fail("Exception unexpectedly raised")
self.raven_client_mock.assert_called_once_with(
mock.ANY,
transport=self.raven_request_mock,
name="snapcraft",
processors=mock.ANY,
release=mock.ANY,
auto_log_stacks=False,
)
config_path = os.path.join(
xdg.BaseDirectory.save_config_path("snapcraft"), "cli.cfg")
self.assertThat(
config_path,
FileContains(
dedent("""\
[Sentry]
always_send = true
""")),
)
# It we have a tty, then the trace should be saved to a file and sent to sentry.
# If we don't have a tty, then the same should happen, but the trace should
# also be printed.
self.error_mock.assert_not_called()
self.exit_mock.assert_called_once_with(1)
expected_calls = [
mock.call(RuntimeError, mock.ANY, mock.ANY, file=_Tracefile(self))
]
if not self.tty:
expected_calls.append(
mock.call(RuntimeError, mock.ANY, mock.ANY, file=sys.stdout))
self.print_exception_mock.assert_has_calls(expected_calls,
any_order=True)
def test_prime_with_installed_snaps(self):
self.useFixture(fixtures.EnvironmentVariable(
'SNAPCRAFT_BUILD_INFO', '1'))
self.fake_snapd.snaps_result = [
{'name': 'test-snap-1',
'revision': 'test-snap-1-revision'},
{'name': 'test-snap-2',
'revision': 'test-snap-2-revision'},
]
self.make_snapcraft_yaml(
textwrap.dedent("""\
parts:
test-part:
plugin: nil
"""))
lifecycle.execute('prime', self.project_options)
expected = textwrap.dedent("""\
name: test
version: 0
summary: test
description: test
confinement: strict
grade: stable
parts:
test-part:
build-packages: []
installed-packages: []
installed-snaps: {}
plugin: nil
prime: []
stage: []
stage-packages: []
uname: Linux test uname 4.10 x86_64
architectures: [{}]
build-packages: []
build-snaps: []
""".format('[test-snap-1=test-snap-1-revision, '
'test-snap-2=test-snap-2-revision]',
self.project_options.deb_arch))
self.assertThat(
os.path.join('prime', 'snap', 'manifest.yaml'),
FileContains(expected))
def test_snapcraft_not_installed_on_host_with_channel_from_environment(
self):
self.useFixture(fixture_setup.FakeStore())
self.useFixture(
fixtures.EnvironmentVariable(
"SNAPCRAFT_BUILD_ENVIRONMENT_CHANNEL_SNAPCRAFT",
"latest/edge"))
snap_injector = SnapInjector(
snap_dir=self.provider._SNAPS_MOUNTPOINT,
registry_filepath=self.registry_filepath,
snap_arch="amd64",
runner=self.provider._run,
snap_dir_mounter=self.provider._mount_snaps_directory,
snap_dir_unmounter=self.provider._unmount_snaps_directory,
file_pusher=self.provider._push_file,
)
snap_injector.add("core")
snap_injector.add("snapcraft")
snap_injector.apply()
self.get_assertion_mock.assert_not_called()
self.provider.run_mock.assert_has_calls([
call(["snap", "set", "core", ANY]),
call(["snap", "watch", "--last=auto-refresh"]),
call(["snap", "install", "--channel", "stable", "core"]),
call([
"snap", "install", "--classic", "--channel", "edge",
"snapcraft"
]),
])
self.provider.mount_mock.assert_not_called()
self.provider.unmount_mock.assert_not_called()
self.provider.push_file_mock.assert_not_called()
self.assertThat(
self.registry_filepath,
FileContains(
dedent("""\
core:
- revision: '10000'
snapcraft:
- revision: '25'
""")),
)
def test_ordered_snap_yaml(self):
with open('snapcraft.yaml', 'w') as s:
s.write(
dedent("""\
apps:
stub-app:
command: sh
grade: stable
version: "2"
assumes: [snapd_227]
architectures: [all]
description: stub description
summary: stub summary
confinement: strict
name: stub-snap
environment:
stub_key: stub-value
epoch: 1
parts:
nothing:
plugin: nil
"""))
self.run_snapcraft('prime')
expected_snap_yaml = dedent("""\
name: stub-snap
version: '2'
summary: stub summary
description: stub description
architectures:
- all
confinement: strict
grade: stable
assumes:
- snapd_227
epoch: 1
environment:
stub_key: stub-value
apps:
stub-app:
command: command-stub-app.wrapper
""")
self.assertThat(os.path.join('prime', 'meta', 'snap.yaml'),
FileContains(expected_snap_yaml))
def test_send_with_config_error_does_not_save_always(self):
self.prompt_mock.return_value = "ALWAYS"
config_path = os.path.join(
xdg.BaseDirectory.save_config_path("snapcraft"), "cli.cfg"
)
with open(config_path, "w") as f:
f.write("bad data")
try:
self.call_handler(RuntimeError("not a SnapcraftError"), True)
except Exception:
self.fail("Exception unexpectedly raised")
self.assert_exception_traceback_exit_1_with_debug()
self.raven_client_mock.assert_called()
# Given the corruption, ensure it hasn't been written to
self.assertThat(config_path, FileContains("bad data"))
def test_pull_with_virtual_build_package(self):
virtual_package = "fortunes-off"
self.addCleanup(subprocess.call,
["sudo", "apt-get", "remove", virtual_package])
self.run_snapcraft("pull", "build-virtual-package")
state_file = os.path.join("snap", ".snapcraft", "state")
self.assertThat(state_file, FileExists())
self.assertThat(
state_file,
FileContains(matcher=Contains(
dedent("""\
- {}={}
""".format(
virtual_package,
integration.get_package_version(
virtual_package, self.distro_series, self.deb_arch),
)))),
)
def test_installs_image(self):
tftp_root = self.make_dir()
self.patch_config(tftp_root)
storage_dir = self.prepare_storage_dir()
release = factory.make_name('release')
arch = factory.make_name('arch')
install_image_from_simplestreams(storage_dir,
release=release,
arch=arch)
install_dir = locate_tftp_path(compose_image_path(
arch, 'generic', release, 'commissioning'),
tftproot=tftp_root)
self.assertItemsEqual(['linux', 'initrd.gz', 'root.tar.gz'],
listdir(install_dir))
self.assertThat(
os.path.join(install_dir, 'linux'),
FileContains(read_text_file(os.path.join(storage_dir, 'linux'))))
def test_download_from_host_dangerous(self):
fake_get_assertion = fixtures.MockPatch(
"snapcraft.internal.repo.snaps.get_assertion",
return_value=b"foo-assert")
self.useFixture(fake_get_assertion)
self.fake_snapd.snaps_result = [{
"id": "fake-snap-id",
"name": "fake-snap",
"channel": "stable",
"revision": "x1",
}]
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable")
snap_pkg.local_download(snap_path="fake-snap.snap",
assertion_path="fake-snap.assert")
self.assertThat("fake-snap.snap", FileExists())
self.assertThat("fake-snap.assert", FileContains(""))
fake_get_assertion.mock.assert_not_called()
def test_save(self):
global_state = GlobalState()
global_state.append_build_packages(self.build_packages)
global_state.append_build_snaps(self.build_snaps)
global_state.set_required_grade(self.required_grade)
global_state.save(filepath="state")
prepend = " - "
if self.build_packages:
build_packages = "\n" + "\n".join(
["{}{}".format(prepend, p) for p in self.build_packages]
)
else:
build_packages = " []"
if self.build_snaps:
build_snaps = "\n" + "\n".join(
["{}{}".format(prepend, p) for p in self.build_snaps]
)
else:
build_snaps = " []"
if self.required_grade:
required_grade = self.required_grade
else:
required_grade = "null"
self.assertThat(
"state",
FileContains(
dedent(
"""\
!GlobalState
assets:
build-packages:{}
build-snaps:{}
required-grade: {}
"""
).format(build_packages, build_snaps, required_grade)
),
)
def test_write_config_writes_config(self):
target_dir = patch_dns_config_path(self)
domain = factory.make_string()
network = IPNetwork('192.168.0.3/24')
ip = factory.pick_ip_in_network(network)
forward_zone = DNSForwardZoneConfig(
domain, mapping={factory.make_string(): ip})
reverse_zone = DNSReverseZoneConfig(domain, network=network)
dnsconfig = DNSConfig((forward_zone, reverse_zone))
dnsconfig.write_config()
self.assertThat(
os.path.join(target_dir, MAAS_NAMED_CONF_NAME),
FileContains(
matcher=ContainsAll(
[
'zone.%s' % domain,
'zone.0.168.192.in-addr.arpa',
MAAS_NAMED_RNDC_CONF_NAME,
])))
def test_normal_operation(self):
options_file = self.make_file(contents=OPTIONS_FILE)
self.run_command('--config-path', options_file)
expected_path = os.path.join(os.path.dirname(options_file), "maas",
MAAS_NAMED_CONF_OPTIONS_INSIDE_NAME)
# Check that the file was re-written with the include statement.
options = read_isc_file(options_file)
self.assertThat(make_isc_string(options),
Contains('include "%s";' % expected_path))
# Check that the backup was made.
options_file_base = os.path.dirname(options_file)
files = os.listdir(options_file_base)
self.assertEqual(2, len(files))
files.remove(os.path.basename(options_file))
[backup_file] = files
backup_file = os.path.join(options_file_base, backup_file)
self.assertThat(backup_file, FileContains(OPTIONS_FILE))
def test_send_and_set_to_always(self):
self.prompt_mock.return_value = self.answer
self.mock_isatty.return_value = self.tty
try:
self.call_handler(RuntimeError("not a SnapcraftError"), False)
except Exception:
self.fail("Exception unexpectedly raised")
if self.tty:
self.raven_client_mock.assert_called_once_with(
mock.ANY,
transport=self.raven_request_mock,
name="snapcraft",
processors=mock.ANY,
release=mock.ANY,
auto_log_stacks=False,
)
config_path = os.path.join(
xdg.BaseDirectory.save_config_path("snapcraft"), "cli.cfg")
self.assertThat(
config_path,
FileContains(
dedent("""\
[Sentry]
always_send = true
""")),
)
# It we have a tty, then the trace should be saved to a file and sent to sentry.
self.assert_print_exception_called_only_tracefile(RuntimeError)
else:
# Cannot prompt if not connected to TTY.
self.raven_client_mock.assert_not_called()
# If we don't have a tty, the trace should be printed and saved to file.
self.assert_print_exception_called_both_stdout_and_tempfile(
RuntimeError)
self.error_mock.assert_called_once_with("not a SnapcraftError")
self.exit_mock.assert_called_once_with(1)
def test_metadata_doesnt_overwrite_desktop_file(self):
os.makedirs(self.directory)
desktop_content = 'setup desktop'
_create_file(
os.path.join(self.directory, 'test-app.desktop'),
content=desktop_content)
def _fake_extractor(file_path):
return extractors.ExtractedMetadata(
desktop_file_ids=['com.example.test-app.desktop'])
self.useFixture(fixture_setup.FakeMetadataExtractor(
'fake', _fake_extractor))
self.generate_meta_yaml(build=True)
expected_desktop = os.path.join(
self.meta_dir, 'gui', 'test-app.desktop')
self.assertThat(expected_desktop, FileContains(desktop_content))
def test_writes_dns_zone_config(self):
target_dir = self.make_dir()
self.patch(DNSForwardZoneConfig, 'target_dir', target_dir)
domain = factory.getRandomString()
hostname = factory.getRandomString()
network = factory.getRandomNetwork()
ip = factory.getRandomIPInNetwork(network)
dns_zone_config = DNSForwardZoneConfig(
domain, serial=random.randint(1, 100),
mapping={hostname: ip}, networks=[network])
dns_zone_config.write_config()
self.assertThat(
os.path.join(target_dir, 'zone.%s' % domain),
FileContains(
matcher=ContainsAll(
[
'%s IN CNAME %s' % (hostname, generated_hostname(ip)),
'%s IN A %s' % (generated_hostname(ip), ip),
])))
def test_generate_desktop_file(self):
d = DesktopFile(
snap_name=self.snap_name,
app_name=self.app_name,
filename=self.desktop_file_path,
prime_dir=self.path,
)
d.write(gui_dir=".")
self.assertThat(self.expected_desktop_file, FileExists())
self.assertThat(
self.expected_desktop_file,
FileContains(
dedent("""\
[Desktop Entry]
Exec={} %U
""").format(self.expected_exec)),
)
def test_ubuntu_ppa(self):
"""A meta-data upload to an Ubuntu PPA is published.
The custom file is published to
/<person_name>/meta/<ppa_name>/<filename>.
"""
ubuntu = getUtility(IDistributionSet)["ubuntu"]
archive = self.factory.makeArchive(distribution=ubuntu)
packageupload = self.factory.makePackageUpload(archive=archive)
content = self.factory.getUniqueString()
libraryfilealias = self.factory.makeLibraryFileAlias(content=content)
transaction.commit()
logger = BufferLogger()
MetaDataUpload(logger=logger).process(packageupload, libraryfilealias)
self.assertEqual("", logger.getLogBuffer())
published_file = os.path.join(
getPubConfig(archive).distroroot, archive.owner.name, "meta",
archive.name, libraryfilealias.filename)
self.assertThat(published_file, FileContains(content))
def test_successful_sign_build_push(self):
if not self.is_store_fake():
# https://bugs.launchpad.net/bugs/1621441
self.skipTest(
'Cannot push signed assertion against staging/production '
'until we have a way to delete them again.')
self.run_snapcraft('snap', self.project)
self.assertThat(self.snap_path, FileExists())
self.assertThat(self.register_key('default'), Equals(0))
self.addCleanup(self.logout)
self.login()
status = self.sign_build(self.snap_path)
self.assertThat(status, Equals(0))
self.assertThat(self.snap_build_path, FileExists())
self.assertThat(self.snap_build_path,
FileContains(matcher=Contains('type: snap-build')))
def test_get(self):
provider = ProviderImpl(project=self.project, echoer=self.echoer_mock)
os.makedirs(provider.provider_project_dir)
cloud_data_filepath = provider._get_cloud_user_data(
timezone="America/Argentina/Cordoba")
self.assertThat(
cloud_data_filepath,
FileContains(
dedent("""\
#cloud-config
manage_etc_hosts: true
package_update: false
growpart:
mode: growpart
devices: ["/"]
ignore_growroot_disabled: false
runcmd:
- ["ln", "-s", "../usr/share/zoneinfo/America/Argentina/Cordoba", "/etc/localtime"]
write_files:
- path: /root/.bashrc
permissions: 0644
content: |
export SNAPCRAFT_BUILD_ENVIRONMENT=managed-host
export PS1="\h \$(/bin/_snapcraft_prompt)# "
export PATH=/snap/bin:$PATH
- path: /bin/_snapcraft_prompt
permissions: 0755
content: |
#!/bin/bash
if [[ "$PWD" =~ ^$HOME.* ]]; then
path="${PWD/#$HOME/\ ..}"
if [[ "$path" == " .." ]]; then
ps1=""
else
ps1="$path"
fi
else
ps1="$PWD"
fi
echo -n $ps1
""")),
)
def test_python(self):
file_path = _create_file(
"file",
textwrap.dedent("""\
#! /usr/bin/python2.7
# Larger file
"""),
)
mangling.rewrite_python_shebangs(os.path.dirname(file_path))
self.assertThat(
file_path,
FileContains(
textwrap.dedent("""\
#!/usr/bin/env python2.7
# Larger file
""")),
)
def test_prime_with_source_details(self, _):
self.useFixture(
fixtures.EnvironmentVariable('SNAPCRAFT_BUILD_INFO', '1'))
self.fake_apt_cache.add_package(
fixture_setup.FakeAptCachePackage('git', 'testversion'))
self.make_snapcraft_yaml("""parts:
test-part:
plugin: nil
source: test-source
source-type: git
source-commit: test-commit
""")
lifecycle.execute('prime', self.project_options)
expected = ("""name: test
version: 0
summary: test
description: test
confinement: strict
grade: stable
parts:
test-part:
build-packages: []
installed-packages: []
plugin: nil
prime: []
source: test-source
source-branch: ''
source-checksum: ''
source-commit: test-commit
source-tag: ''
source-type: git
stage: []
stage-packages: []
uname: Linux test uname 4.10 x86_64
architectures: [{}]
build-packages: [git=testversion]
build-snaps: []
""".format(self.project_options.deb_arch))
self.assertThat(os.path.join('prime', 'snap', 'manifest.yaml'),
FileContains(expected))
def test_prime_with_installed_packages(self):
self.useFixture(
fixtures.EnvironmentVariable('SNAPCRAFT_BUILD_INFO', '1'))
for name, version in [('test-package1', 'test-version1'),
('test-package2', 'test-version2')]:
self.fake_apt_cache.add_package(
fixture_setup.FakeAptCachePackage(name,
version,
installed=True))
self.make_snapcraft_yaml(
textwrap.dedent("""\
parts:
test-part:
plugin: nil
"""))
lifecycle.execute('prime', self.project_options)
expected = textwrap.dedent("""\
name: test
version: 0
summary: test
description: test
confinement: strict
grade: stable
parts:
test-part:
build-packages: []
installed-packages: {}
installed-snaps: []
plugin: nil
prime: []
stage: []
stage-packages: []
uname: Linux test uname 4.10 x86_64
architectures: [{}]
build-packages: []
build-snaps: []
""".format(
'[test-package1=test-version1, '
'test-package2=test-version2]', self.project_options.deb_arch))
self.assertThat(os.path.join('prime', 'snap', 'manifest.yaml'),
FileContains(expected))
def test_handles_slash_32_dynamic_range(self):
target_dir = patch_dns_config_path(self)
domain = factory.make_string()
network = factory.make_ipv4_network()
ipv4_hostname = factory.make_name("host")
ipv4_ip = factory.pick_ip_in_network(network)
range_ip = factory.pick_ip_in_network(network, but_not={ipv4_ip})
ipv6_hostname = factory.make_name("host")
ipv6_ip = factory.make_ipv6_address()
ttl = random.randint(10, 300)
mapping = {
ipv4_hostname: HostnameIPMapping(None, ttl, {ipv4_ip}),
ipv6_hostname: HostnameIPMapping(None, ttl, {ipv6_ip}),
}
dynamic_range = IPRange(IPAddress(range_ip), IPAddress(range_ip))
expected_generate_directives = DNSForwardZoneConfig.get_GENERATE_directives(
dynamic_range)
other_mapping = {
ipv4_hostname: HostnameRRsetMapping(None, {(ttl, "MX", "10 bar")})
}
dns_zone_config = DNSForwardZoneConfig(
domain,
serial=random.randint(1, 100),
other_mapping=other_mapping,
default_ttl=ttl,
mapping=mapping,
dynamic_ranges=[dynamic_range],
)
dns_zone_config.write_config()
self.assertThat(
os.path.join(target_dir, "zone.%s" % domain),
FileContains(matcher=ContainsAll([
"$TTL %d" % ttl,
"%s %d IN A %s" % (ipv4_hostname, ttl, ipv4_ip),
"%s %d IN AAAA %s" % (ipv6_hostname, ttl, ipv6_ip),
"%s %d IN MX 10 bar" % (ipv4_hostname, ttl),
] + [
"$GENERATE %s %s IN A %s" %
(iterator_values, reverse_dns, hostname) for iterator_values,
reverse_dns, hostname in expected_generate_directives
])),
)
def test_prime_with_virtual_build_package(self, _):
self.useFixture(
fixtures.EnvironmentVariable('SNAPCRAFT_BUILD_INFO', '1'))
self.fake_apt_cache.add_package(
fixture_setup.FakeAptCachePackage(
'test-provider-package',
'test-version',
provides=['test-virtual-package']))
self.make_snapcraft_yaml(
textwrap.dedent("""\
parts:
test-part:
plugin: nil
build-packages: ['test-virtual-package']
"""))
lifecycle.execute('prime', self.project_options)
expected = textwrap.dedent("""\
name: test
version: 0
summary: test
description: test
confinement: strict
grade: stable
parts:
test-part:
build-packages: [test-virtual-package]
installed-packages: []
installed-snaps: []
plugin: nil
prime: []
stage: []
stage-packages: []
uname: Linux test uname 4.10 x86_64
architectures: [{}]
build-packages: [test-provider-package=test-version]
build-snaps: []
""".format(self.project_options.deb_arch))
self.assertThat(os.path.join('prime', 'snap', 'manifest.yaml'),
FileContains(expected))
def test_snap(self):
self.copy_project_to_cwd('assemble')
self.run_snapcraft('snap')
snap_file_path = 'assemble_1.0_{}.snap'.format(self.deb_arch)
self.assertThat(snap_file_path, FileExists())
binary1_wrapper_path = os.path.join(self.prime_dir,
'command-assemble-bin.wrapper')
with open('binary1.after', 'r') as file_:
expected_binary1_wrapper = file_.read()
self.assertThat(binary1_wrapper_path,
FileContains(expected_binary1_wrapper))
self.useFixture(
fixtures.EnvironmentVariable(
'SNAP', os.path.join(os.getcwd(), self.prime_dir)))
binary_scenarios = (
('command-assemble-service.wrapper', 'service-start\n'),
('stop-command-assemble-service.wrapper', 'service-stop\n'),
('command-assemble-bin.wrapper', 'binary1\n'),
('command-binary2.wrapper', 'binary2\n'),
)
for binary, expected_output in binary_scenarios:
output = subprocess.check_output(os.path.join(
self.prime_dir, binary),
universal_newlines=True)
self.assertThat(output, Equals(expected_output))
with testtools.ExpectedException(subprocess.CalledProcessError):
subprocess.check_output(os.path.join(self.prime_dir, 'bin',
'not-wrapped'),
stderr=subprocess.STDOUT)
self.assertThat(
os.path.join(self.prime_dir, 'bin', 'not-wrapped.wrapper'),
Not(FileExists()))
self.assertThat(
os.path.join(self.prime_dir, 'bin',
'command-binary-wrapper-none.wrapper.wrapper'),
Not(FileExists()))
def test_save(self):
global_state = GlobalState()
global_state.append_build_packages(self.build_packages)
global_state.append_build_snaps(self.build_snaps)
global_state.save(filepath="state")
build_packages_str = ", ".join(self.build_packages)
build_snaps_str = ", ".join(self.build_snaps)
self.assertThat(
"state",
FileContains(
dedent("""\
!GlobalState
assets:
build-packages: [{}]
build-snaps: [{}]
""").format(build_packages_str, build_snaps_str)),
)
def test_classic_app_with_snapd_workaround(self):
"""Test workaround for classic (LP: #1860369)."""
apps = dict(testapp=dict(command="echo"))
sp = self._get_snap_packaging(apps=apps,
base="core18",
confinement="classic")
runner = sp._generate_snapcraft_runner()
self.expectThat(runner, Equals("snap/command-chain/snapcraft-runner"))
runner_path = Path(self.path, "prime", runner)
self.expectThat(
runner_path,
FileContains(
textwrap.dedent("""
#!/bin/sh
exec "$@"
""").lstrip()),
)
def test_wrap_exe_writes_wrapper_with_basename(self, mock_assemble_env):
mock_assemble_env.return_value = """\
PATH={0}/part1/install/usr/bin:{0}/part1/install/bin
""".format(self.parts_dir)
relative_exe_path = 'test_relexepath'
_create_file(os.path.join(self.prime_dir, relative_exe_path))
relative_wrapper_path = self.packager._wrap_exe(relative_exe_path,
basename='new-name')
wrapper_path = os.path.join(self.prime_dir, relative_wrapper_path)
self.assertThat(relative_wrapper_path, Equals('new-name.wrapper'))
expected = ('#!/bin/sh\n'
'PATH=$SNAP/usr/bin:$SNAP/bin\n\n'
'export LD_LIBRARY_PATH=$SNAP_LIBRARY_PATH:'
'$LD_LIBRARY_PATH\n'
'exec "$SNAP/test_relexepath" "$@"\n')
self.assertThat(wrapper_path, FileContains(expected))
def test_write_snap_directory(self):
# Setup a snap directory containing a few things.
_create_file(os.path.join(self.snap_dir, 'snapcraft.yaml'))
_create_file(os.path.join(self.snap_dir, 'hooks', 'test-hook'),
executable=True)
# Now write the snap directory, and verify everything was migrated, as
# well as the hook making it into meta/.
self.generate_meta_yaml()
prime_snap_dir = os.path.join(self.prime_dir, 'snap')
self.assertThat(os.path.join(prime_snap_dir, 'hooks', 'test-hook'),
FileExists())
self.assertThat(os.path.join(self.hooks_dir, 'test-hook'),
FileExists())
# The hook should be empty, because the one in snap/hooks is empty, and
# no wrapper is generated (i.e. that hook is copied to both locations).
self.assertThat(os.path.join(self.hooks_dir, 'test-hook'),
FileContains(''))
