def test_cleaning_with_strip_does_prime_and_warns(self, mock_clean):
fake_logger = fixtures.FakeLogger(level=logging.WARNING)
self.useFixture(fake_logger)
self.make_snapcraft_yaml(n=3)
main(['clean', '--step=strip'])
expected_staged_state = {
'clean0': states.StageState({'clean0'}, set()),
'clean1': states.StageState({'clean1'}, set()),
'clean2': states.StageState({'clean2'}, set()),
}
expected_primed_state = {
'clean0': states.PrimeState({'clean0'}, set()),
'clean1': states.PrimeState({'clean1'}, set()),
'clean2': states.PrimeState({'clean2'}, set()),
}
self.assertEqual(
'DEPRECATED: Use `prime` instead of `strip` as '
'the step to clean\n', fake_logger.output)
mock_clean.assert_called_with(expected_staged_state,
expected_primed_state, 'prime')
def test_clean_prime_state_multiple_parts(self):
self.assertRaises(errors.NoLatestStepError, self.handler.latest_step)
self.assertThat(self.handler.next_step(), Equals(steps.PULL))
bindir = os.path.join(self.prime_dir, "bin")
os.makedirs(bindir)
open(os.path.join(bindir, "1"), "w").close()
open(os.path.join(bindir, "2"), "w").close()
open(os.path.join(bindir, "3"), "w").close()
self.handler.mark_done(steps.STAGE)
self.handler.mark_done(
steps.PRIME, states.PrimeState({"bin/1", "bin/2"}, {"bin"})
)
self.handler.clean_prime({})
self.assertThat(self.handler.latest_step(), Equals(steps.STAGE))
self.assertThat(self.handler.next_step(), Equals(steps.PRIME))
self.assertFalse(os.path.exists(os.path.join(bindir, "1")))
self.assertFalse(os.path.exists(os.path.join(bindir, "2")))
self.assertTrue(
os.path.exists(os.path.join(bindir, "3")),
"Expected 'bin/3' to remain as it wasn't primed by this part",
)
def test_per_step_cleaning(self, mock_clean):
self.make_snapcraft_yaml(n=3)
main(['clean', '--step=foo'])
expected_staged_state = {
'clean0': states.StageState({'clean0'}, set()),
'clean1': states.StageState({'clean1'}, set()),
'clean2': states.StageState({'clean2'}, set()),
}
expected_primed_state = {
'clean0': states.PrimeState({'clean0'}, set()),
'clean1': states.PrimeState({'clean1'}, set()),
'clean2': states.PrimeState({'clean2'}, set()),
}
mock_clean.assert_called_with(expected_staged_state,
expected_primed_state, 'foo')
def mark_prime_done(self, snap_files, snap_dirs, dependency_paths):
self.mark_done(
steps.PRIME,
states.PrimeState(
snap_files,
snap_dirs,
dependency_paths,
self._part_properties,
self._project_options,
self._scriptlet_metadata[steps.PRIME],
),
)
def prime(self, force=False):
self.makedirs()
self.notify_part_progress('Priming')
snap_files, snap_dirs = self.migratable_fileset_for('snap')
_migrate_files(snap_files, snap_dirs, self.stagedir, self.snapdir)
dependencies = _find_dependencies(self.snapdir)
# Split the necessary dependencies into their corresponding location.
# We'll both migrate and track the system dependencies, but we'll only
# track the part and staged dependencies, since they should have
# already been primed by other means, and migrating them again could
# potentially override the `stage` or `snap` filtering.
part_dependencies = set()
staged_dependencies = set()
primed_dependencies = set()
system_dependencies = set()
for file_path in dependencies:
if file_path.startswith(self.installdir):
part_dependencies.add(
os.path.relpath(file_path, self.installdir))
elif file_path.startswith(self.stagedir):
staged_dependencies.add(
os.path.relpath(file_path, self.stagedir))
elif file_path.startswith(self.snapdir):
primed_dependencies.add(
os.path.relpath(file_path, self.snapdir))
else:
system_dependencies.add(file_path.lstrip('/'))
part_dependency_paths = {os.path.dirname(d) for d in part_dependencies}
staged_dependency_paths = {
os.path.dirname(d)
for d in staged_dependencies
}
system_dependency_paths = {
os.path.dirname(d)
for d in system_dependencies
}
# Lots of dependencies are linked with a symlink, so we need to make
# sure we follow those symlinks when we migrate the dependencies.
_migrate_files(system_dependencies,
system_dependency_paths,
'/',
self.snapdir,
follow_symlinks=True)
dependency_paths = (part_dependency_paths | staged_dependency_paths
| system_dependency_paths)
self.mark_done(
'prime',
states.PrimeState(snap_files, snap_dirs, dependency_paths,
self.code.options, self._project_options))
def test_clean_prime_state_common_files(self):
self.assertRaises(errors.NoLatestStepError, self.handler.latest_step)
self.assertThat(self.handler.next_step(), Equals(steps.PULL))
bindir = os.path.join(self.prime_dir, "bin")
os.makedirs(bindir)
open(os.path.join(bindir, "1"), "w").close()
open(os.path.join(bindir, "2"), "w").close()
self.handler.mark_done(steps.STAGE)
self.handler.mark_done(steps.PRIME,
states.PrimeState({"bin/1", "bin/2"}, {"bin"}))
self.handler.clean_prime(
{"other_part": states.PrimeState({"bin/2"}, {"bin"})})
self.assertThat(self.handler.latest_step(), Equals(steps.STAGE))
self.assertThat(self.handler.next_step(), Equals(steps.PRIME))
self.assertFalse(os.path.exists(os.path.join(bindir, "1")))
self.assertTrue(
os.path.exists(os.path.join(bindir, "2")),
"Expected 'bin/2' to remain as it's required by other parts",
)
def test_clean_prime_state(self):
self.assertRaises(errors.NoLatestStepError, self.handler.latest_step)
self.assertThat(self.handler.next_step(), Equals(steps.PULL))
bindir = os.path.join(self.prime_dir, "bin")
os.makedirs(bindir)
open(os.path.join(bindir, "1"), "w").close()
open(os.path.join(bindir, "2"), "w").close()
self.handler.mark_done(steps.STAGE)
self.handler.mark_done(steps.PRIME,
states.PrimeState({"bin/1", "bin/2"}, {"bin"}))
self.handler.clean_prime({})
self.assertThat(self.handler.latest_step(), Equals(steps.STAGE))
self.assertThat(self.handler.next_step(), Equals(steps.PRIME))
self.assertFalse(os.path.exists(bindir))
def test_clean_prime_state_inconsistent_files(self):
self.assertRaises(errors.NoLatestStepError, self.handler.latest_step)
self.assertThat(self.handler.next_step(), Equals(steps.PULL))
self.handler.mark_done(steps.STAGE)
self.handler.mark_done(
steps.PRIME,
states.PrimeState({"bin/1", "bin/2"}, {"bin", "not-there"}))
# Only create a subset of the files and directories that were marked as primed
bindir = os.path.join(self.prime_dir, "bin")
os.makedirs(bindir)
open(os.path.join(bindir, "1"), "w").close()
self.handler.clean_prime({})
self.assertThat(self.handler.latest_step(), Equals(steps.STAGE))
self.assertThat(self.handler.next_step(), Equals(steps.PRIME))
self.assertFalse(os.path.exists(bindir))
def mark_prime_done(self, snap_files, snap_dirs, dependency_paths):
self.mark_done(
'prime',
states.PrimeState(snap_files, snap_dirs, dependency_paths,
self._part_properties, self._project_options))
def prime_state_variant(request):
"""Return variants of prime_state."""
project, files, directories, dependency_paths, part_properties = request.param
return states.PrimeState(files, directories, dependency_paths,
part_properties, project)
def prime_state():
"""Return a PrimeState."""
project, files, directories, dependency_paths, part_properties = _PRIME_DEFAULT
return states.PrimeState(files, directories, dependency_paths,
part_properties, project)
