def test_installed(self):
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable/branch")
snap_pkg.get_local_snap_info = lambda: {
"channel": "strict/stable/branch"
}
self.assertTrue(snap_pkg.is_valid())
def test_install_non_classic(self):
self.fake_snapd.find_result = [{
"fake-snap": {
"channels": {
"strict/stable": {
"confinement": "strict"
}
}
}
}]
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable")
snap_pkg.install()
self.assertThat(
self.fake_snap_command.calls,
Equals([
["snap", "whoami"],
[
"sudo",
"snap",
"install",
"fake-snap",
"--channel",
"strict/stable",
],
]),
)
def test_download_from_host(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": "10",
}]
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("foo-assert\nfoo-assert\nfoo-assert\n"))
fake_get_assertion.mock.assert_has_calls([
mock.call([
"account-key",
"public-key-sha3-384=BWDEoaqyr25nF5SNCvEv2v7QnM9QsfCc0PBMYD_i2NGSQ32EF2d4D0hqUel3m8ul",
]),
mock.call(["snap-declaration", "snap-name=fake-snap"]),
mock.call(
["snap-revision", "snap-revision=10", "snap-id=fake-snap-id"]),
])
def test_refresh_to_classic(self):
self.fake_snapd.find_result = [{
"fake-snap": {
"channels": {
"classic/stable": {
"confinement": "classic"
}
}
}
}]
snap_pkg = snaps.SnapPackage("fake-snap/classic/stable")
snap_pkg.refresh()
self.assertThat(
self.fake_snap_command.calls,
Equals([
["snap", "whoami"],
[
"sudo",
"snap",
"refresh",
"fake-snap",
"--channel",
"classic/stable",
"--classic",
],
]),
)
def test_refresh_fails(self):
self.fake_snapd.find_result = [
{"fake-snap": {"channels": {"strict/stable": {"confinement": "strict"}}}}
]
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable")
self.fake_snap_command.refresh_success = False
self.assertRaises(errors.SnapRefreshError, snap_pkg.refresh)
def test_refresh_fails(self):
self.fake_snapd.find_result = [{
'fake-snap': {'channels': {
'strict/stable': {'confinement': 'strict'}}}}]
snap_pkg = snaps.SnapPackage('fake-snap/strict/stable')
self.fake_snap_command.refresh_success = False
self.assertRaises(errors.SnapRefreshError, snap_pkg.refresh)
def _inject_snap(self, name: str, tmp_dir: str):
snap = snaps.SnapPackage(name)
if not snap.installed:
raise errors.ContainerSnapNotFoundError(name)
snap_info = snap.get_local_snap_info()
id = snap_info["id"]
# Lookup confinement to know if we need to --classic when installing
is_classic = snap_info["confinement"] == "classic"
# If the server has a different arch we can't inject local snaps
target_arch = self._project_options.target_arch
if target_arch and target_arch != self._get_container_arch():
channel = snap_info["channel"]
return self._install_snap(name, channel, is_classic=is_classic)
# Revisions are unique, so we don't need to know the channel
rev = snap_info["revision"]
# https://github.com/snapcore/snapd/blob/master/snap/info.go
# MountFile
filename = "{}_{}.snap".format(name, rev)
# https://github.com/snapcore/snapd/blob/master/dirs/dirs.go
# CoreLibExecDir
installed = os.path.join(os.path.sep, "var", "lib", "snapd", "snaps", filename)
filepath = os.path.join(tmp_dir, filename)
if rev.startswith("x"):
logger.info("Making {} user-accessible".format(filename))
subprocess.check_call(["sudo", "cp", installed, filepath])
subprocess.check_call(["sudo", "chown", str(os.getuid()), filepath])
else:
shutil.copyfile(installed, filepath)
if self._is_same_snap(filepath, name):
logger.debug("Not re-injecting same version of {!r}".format(name))
return
if not rev.startswith("x"):
self._inject_assertions(
"{}_{}.assert".format(name, rev),
[
["account-key", "public-key-sha3-384={}".format(_STORE_KEY)],
["snap-declaration", "snap-name={}".format(name)],
[
"snap-revision",
"snap-revision={}".format(rev),
"snap-id={}".format(id),
],
],
tmp_dir,
)
container_filename = os.path.join(os.sep, "run", filename)
self._push_file(filepath, container_filename)
self._install_snap(
container_filename, is_dangerous=rev.startswith("x"), is_classic=is_classic
)
def test_refresh_to_classic(self):
snap_pkg = snaps.SnapPackage('fake-snap/classic/stable')
snap_pkg.refresh()
self.assertThat(
self.fake_snap_command.calls,
Equals([['snap', 'whoami'],
[
'sudo', 'snap', 'refresh', 'fake-snap', '--channel',
'classic/stable', '--classic'
]]))
def test_install_non_classic(self):
snap_pkg = snaps.SnapPackage('fake-snap/strict/stable')
snap_pkg.install()
self.assertThat(
self.fake_snap_command.calls,
Equals([['snap', 'whoami'],
[
'sudo', 'snap', 'install', 'fake-snap', '--channel',
'strict/stable'
]]))
def test_download_classic(self):
self.fake_snapd.find_result = [
{"fake-snap": {"channels": {"classic/stable": {"confinement": "classic"}}}}
]
snap_pkg = snaps.SnapPackage("fake-snap")
snap_pkg.download()
self.assertThat(
self.fake_snap_command.calls, Equals([["snap", "download", "fake-snap"]])
)
def test_download_channel(self):
self.fake_snapd.find_result = [
{"fake-snap": {"channels": {"strict/edge": {"confinement": "strict"}}}}
]
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable")
snap_pkg.download()
self.assertThat(
self.fake_snap_command.calls,
Equals([["snap", "download", "fake-snap", "--channel", "strict/stable"]]),
)
def _inject_snap(self, name: str, tmp_dir: str):
snap = snaps.SnapPackage(name)
if not snap.installed:
raise errors.ContainerSnapNotFoundError(name)
snap_info = snap.get_local_snap_info()
id = snap_info['id']
# Lookup confinement to know if we need to --classic when installing
is_classic = snap_info['confinement'] == 'classic'
# If the server has a different arch we can't inject local snaps
target_arch = self._project_options.target_arch
if (target_arch and target_arch != self._get_container_arch()):
channel = snap_info['channel']
return self._install_snap(name, channel, is_classic=is_classic)
# Revisions are unique, so we don't need to know the channel
rev = snap_info['revision']
# https://github.com/snapcore/snapd/blob/master/snap/info.go
# MountFile
filename = '{}_{}.snap'.format(name, rev)
# https://github.com/snapcore/snapd/blob/master/dirs/dirs.go
# CoreLibExecDir
installed = os.path.join(os.path.sep, 'var', 'lib', 'snapd', 'snaps',
filename)
filepath = os.path.join(tmp_dir, filename)
if rev.startswith('x'):
logger.info('Making {} user-accessible'.format(filename))
subprocess.check_call(['sudo', 'cp', installed, filepath])
subprocess.check_call(
['sudo', 'chown', str(os.getuid()), filepath])
else:
shutil.copyfile(installed, filepath)
if self._is_same_snap(filepath, name):
logger.debug('Not re-injecting same version of {!r}'.format(name))
return
if not rev.startswith('x'):
self._inject_assertions('{}_{}.assert'.format(name, rev), [
['account-key', 'public-key-sha3-384={}'.format(_STORE_KEY)],
['snap-declaration', 'snap-name={}'.format(name)],
[
'snap-revision', 'snap-revision={}'.format(rev),
'snap-id={}'.format(id)
],
], tmp_dir)
container_filename = os.path.join(os.sep, 'run', filename)
self._push_file(filepath, container_filename)
self._install_snap(container_filename,
is_dangerous=rev.startswith('x'),
is_classic=is_classic)
def test_install_non_classic(self):
self.fake_snapd.find_result = [{
'fake-snap': {'channels': {
'strict/stable': {'confinement': 'strict'}}}}]
snap_pkg = snaps.SnapPackage('fake-snap/strict/stable')
snap_pkg.install()
self.assertThat(self.fake_snap_command.calls, Equals([
['snap', 'whoami'],
['sudo', 'snap', 'install', 'fake-snap',
'--channel', 'strict/stable']]))
def test_refresh_to_classic(self):
self.fake_snapd.find_result = [{
'fake-snap': {'channels': {
'classic/stable': {'confinement': 'classic'}}}}]
snap_pkg = snaps.SnapPackage('fake-snap/classic/stable')
snap_pkg.refresh()
self.assertThat(self.fake_snap_command.calls, Equals([
['snap', 'whoami'],
['sudo', 'snap', 'refresh', 'fake-snap',
'--channel', 'classic/stable', '--classic']]))
def test_refresh_logged_in(self):
self.fake_snap_command.login('*****@*****.**')
snap_pkg = snaps.SnapPackage('fake-snap/strict/stable')
snap_pkg.refresh()
self.assertThat(
self.fake_snap_command.calls,
Equals([['snap', 'whoami'],
[
'snap', 'refresh', 'fake-snap', '--channel',
'strict/stable'
]]))
def test_prime_records_installed_snaps(self):
self.run_snapcraft('prime', project_dir='basic')
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)
expected_package = 'core={}'.format(
snaps.SnapPackage('core').get_local_snap_info()['revision'])
self.assertThat(
recorded_yaml['parts']['dummy-part']['installed-snaps'],
Contains(expected_package))
def test_refresh_branch(self):
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable/branch")
snap_pkg.refresh()
self.assertThat(
self.fake_snap_command.calls,
Equals([
["snap", "whoami"],
[
"sudo",
"snap",
"refresh",
"fake-snap",
"--channel",
"strict/stable/branch",
],
]),
)
def test_prime_records_installed_snaps(self):
if os.environ.get('ADT_TEST') and self.deb_arch == 'armhf':
self.skipTest("The autopkgtest armhf runners can't install snaps")
subprocess.check_call(['sudo', 'snap', 'install', 'core'])
self.run_snapcraft('prime', project_dir='basic')
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)
expected_package = 'core={}'.format(
snaps.SnapPackage('core').get_local_snap_info()['revision'])
self.assertThat(
recorded_yaml['parts']['dummy-part']['installed-snaps'],
Contains(expected_package))
def test_refresh_logged_in(self):
self.fake_snapd.find_result = [
{"fake-snap": {"channels": {"strict/stable": {"confinement": "strict"}}}}
]
self.fake_snap_command.login("*****@*****.**")
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable")
snap_pkg.refresh()
self.assertThat(
self.fake_snap_command.calls,
Equals(
[
["snap", "whoami"],
["snap", "refresh", "fake-snap", "--channel", "strict/stable"],
]
),
)
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_install_classic_not_on_channel(self):
self.fake_snapd.find_result = [{"fake-snap": {"channels": {}}}]
snap_pkg = snaps.SnapPackage("fake-snap/classic/stable")
snap_pkg.install()
self.assertThat(
self.fake_snap_command.calls,
Equals([
["snap", "whoami"],
[
"sudo",
"snap",
"install",
"fake-snap",
"--channel",
"classic/stable",
],
]),
)
def test_prime_records_build_snaps(self):
self.useFixture(fixture_setup.WithoutSnapInstalled('hello'))
snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path)
snapcraft_yaml.update_part('test-part', {
'plugin': 'nil',
'build-snaps': ['hello']
})
self.useFixture(snapcraft_yaml)
self.run_snapcraft('prime')
expected_revision = snaps.SnapPackage(
'hello').get_local_snap_info()['revision']
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['build-snaps'],
Equals(['hello={}'.format(expected_revision)]))
def test_prime_records_build_snaps(self):
if os.environ.get('ADT_TEST') and self.deb_arch == 'armhf':
self.skipTest("The autopkgtest armhf runners can't install snaps")
self.useFixture(fixture_setup.WithoutSnapInstalled('hello'))
snapcraft_yaml = fixture_setup.SnapcraftYaml(self.path)
snapcraft_yaml.update_part('test-part', {
'plugin': 'nil',
'build-snaps': ['hello']
})
self.useFixture(snapcraft_yaml)
self.run_snapcraft('prime')
expected_revision = snaps.SnapPackage(
'hello').get_local_snap_info()['revision']
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['build-snaps'],
Equals(['hello={}'.format(expected_revision)]))
def test_get_current_channel(self):
self.fake_snapd.snaps_result = self.installed_snaps
snap_pkg = snaps.SnapPackage(self.snap)
self.assertThat(snap_pkg.get_current_channel(), Equals(self.expected))
def assert_channels(self, snap, installed_snaps, expected):
self.fake_snapd.snaps_result = installed_snaps
snap_pkg = snaps.SnapPackage(snap)
self.assertThat(snap_pkg.get_current_channel(), Equals(expected))
def test_is_valid(self):
self.fake_snapd.find_result = self.find_result
snap_pkg = snaps.SnapPackage(self.snap)
self.assertThat(snap_pkg.is_valid(), Is(self.expected))
def test_is_installed(self):
self.fake_snapd.snaps_result = self.installed_snaps
snap_pkg = snaps.SnapPackage(self.snap)
self.assertThat(snap_pkg.installed, Is(self.expected))
def test_install_fails(self):
self.fake_snap_command.install_success = False
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable")
self.assertRaises(errors.SnapInstallError, snap_pkg.install)
def assert_installed(self, snap, installed_snaps, expected):
self.fake_snapd.snaps_result = installed_snaps
snap_pkg = snaps.SnapPackage(snap)
self.expectThat(snap_pkg.installed, Is(expected))
self.expectThat(snaps.SnapPackage.is_snap_installed(snap),
Is(expected))
def test_refresh_fails(self):
snap_pkg = snaps.SnapPackage("fake-snap/strict/stable")
self.fake_snap_command.refresh_success = False
self.assertRaises(errors.SnapRefreshError, snap_pkg.refresh)
