diff --git a/swh/loader/package/loader.py b/swh/loader/package/loader.py
index 174df8d..11a5a71 100644
--- a/swh/loader/package/loader.py
+++ b/swh/loader/package/loader.py
@@ -1,452 +1,487 @@
 # Copyright (C) 2019-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import datetime
 import logging
 import tempfile
 import os
 
 from typing import (
     Any, Dict, Generator, List, Mapping, Optional, Sequence, Tuple
 )
 
 import attr
+import sentry_sdk
 
 from swh.core.tarball import uncompress
 from swh.core.config import SWHConfig
 from swh.model import from_disk
 from swh.model.hashutil import hash_to_hex
 from swh.model.model import (
     BaseModel, Sha1Git,
     Content, SkippedContent, Directory,
     Revision,
     TargetType, Snapshot,
     Origin
 )
 from swh.storage import get_storage
 from swh.storage.algos.snapshot import snapshot_get_all_branches
 
 from swh.loader.package.utils import download
 
 
 logger = logging.getLogger(__name__)
 
 
 class PackageLoader:
     # Origin visit type (str) set by the loader
     visit_type = ''
 
     def __init__(self, url):
         """Loader's constructor. This raises exception if the minimal required
            configuration is missing (cf. fn:`check` method).
 
         Args:
             url (str): Origin url to load data from
 
         """
         # This expects to use the environment variable SWH_CONFIG_FILENAME
         self.config = SWHConfig.parse_config_file()
         self._check_configuration()
         self.storage = get_storage(**self.config['storage'])
         self.url = url
         self.visit_date = datetime.datetime.now(tz=datetime.timezone.utc)
         self.max_content_size = self.config['max_content_size']
 
     def _check_configuration(self):
         """Checks the minimal configuration required is set for the loader.
 
         If some required configuration is missing, exception detailing the
         issue is raised.
 
         """
         if 'storage' not in self.config:
             raise ValueError(
                 'Misconfiguration, at least the storage key should be set')
 
     def get_versions(self) -> Sequence[str]:
         """Return the list of all published package versions.
 
         Returns:
             Sequence of published versions
 
         """
         return []
 
     def get_package_info(self, version: str) -> Generator[
             Tuple[str, Mapping[str, Any]], None, None]:
         """Given a release version of a package, retrieve the associated
            package information for such version.
 
         Args:
             version: Package version
 
         Returns:
             (branch name, package metadata)
 
         """
         yield from {}
 
     def build_revision(
             self, a_metadata: Dict, uncompressed_path: str,
             directory: Sha1Git) -> Optional[Revision]:
         """Build the revision from the archive metadata (extrinsic
         artifact metadata) and the intrinsic metadata.
 
         Args:
             a_metadata: Artifact metadata
             uncompressed_path: Artifact uncompressed path on disk
 
         Returns:
             SWH data dict
 
         """
         raise NotImplementedError('build_revision')
 
     def get_default_version(self) -> str:
         """Retrieve the latest release version if any.
 
         Returns:
             Latest version
 
         """
         return ''
 
     def last_snapshot(self) -> Optional[Snapshot]:
         """Retrieve the last snapshot
 
         """
         snapshot = None
         visit = self.storage.origin_visit_get_latest(
             self.url, require_snapshot=True)
         if visit and visit.get('snapshot'):
             snapshot = Snapshot.from_dict(snapshot_get_all_branches(
                     self.storage, visit['snapshot']))
         return snapshot
 
     def known_artifacts(
             self, snapshot: Optional[Snapshot]) -> Dict[Sha1Git, BaseModel]:
         """Retrieve the known releases/artifact for the origin.
 
         Args
             snapshot: snapshot for the visit
 
         Returns:
             Dict of keys revision id (bytes), values a metadata Dict.
 
         """
         if not snapshot:
             return {}
 
         # retrieve only revisions (e.g the alias we do not want here)
         revs = [rev.target
                 for rev in snapshot.branches.values()
                 if rev and rev.target_type == TargetType.REVISION]
         known_revisions = self.storage.revision_get(revs)
 
         ret = {}
         for revision in known_revisions:
             if not revision:  # revision_get can return None
                 continue
             ret[revision['id']] = revision['metadata']
 
         return ret
 
     def resolve_revision_from(
             self, known_artifacts: Dict, artifact_metadata: Dict) \
             -> Optional[bytes]:
         """Resolve the revision from a snapshot and an artifact metadata dict.
 
         If the artifact has already been downloaded, this will return the
         existing revision targeting that uncompressed artifact directory.
         Otherwise, this returns None.
 
         Args:
             snapshot: Snapshot
             artifact_metadata: Information dict
 
         Returns:
             None or revision identifier
 
         """
         return None
 
     def download_package(self, p_info: Mapping[str, Any],
                          tmpdir: str) -> List[Tuple[str, Mapping]]:
         """Download artifacts for a specific package. All downloads happen in
         in the tmpdir folder.
 
         Default implementation expects the artifacts package info to be
         about one artifact per package.
 
         Note that most implementation have 1 artifact per package. But some
         implementation have multiple artifacts per package (debian), some have
         none, the package is the artifact (gnu).
 
         Args:
             artifacts_package_info: Information on the package artifacts to
                 download (url, filename, etc...)
             tmpdir: Location to retrieve such artifacts
 
         Returns:
             List of (path, computed hashes)
 
         """
         a_uri = p_info['url']
         filename = p_info.get('filename')
         return [download(a_uri, dest=tmpdir, filename=filename)]
 
     def uncompress(self, dl_artifacts: List[Tuple[str, Mapping[str, Any]]],
                    dest: str) -> str:
         """Uncompress the artifact(s) in the destination folder dest.
 
         Optionally, this could need to use the p_info dict for some more
         information (debian).
 
         """
         uncompressed_path = os.path.join(dest, 'src')
         for a_path, _ in dl_artifacts:
             uncompress(a_path, dest=uncompressed_path)
         return uncompressed_path
 
     def extra_branches(self) -> Dict[bytes, Mapping[str, Any]]:
         """Return an extra dict of branches that are used to update the set of
         branches.
 
         """
         return {}
 
     def load(self) -> Dict:
         """Load for a specific origin the associated contents.
 
         for each package version of the origin
 
         1. Fetch the files for one package version By default, this can be
            implemented as a simple HTTP request. Loaders with more specific
            requirements can override this, e.g.: the PyPI loader checks the
            integrity of the downloaded files; the Debian loader has to download
            and check several files for one package version.
 
         2. Extract the downloaded files By default, this would be a universal
            archive/tarball extraction.
 
            Loaders for specific formats can override this method (for instance,
            the Debian loader uses dpkg-source -x).
 
         3. Convert the extracted directory to a set of Software Heritage
            objects Using swh.model.from_disk.
 
         4. Extract the metadata from the unpacked directories This would only
            be applicable for "smart" loaders like npm (parsing the
            package.json), PyPI (parsing the PKG-INFO file) or Debian (parsing
            debian/changelog and debian/control).
 
            On "minimal-metadata" sources such as the GNU archive, the lister
            should provide the minimal set of metadata needed to populate the
            revision/release objects (authors, dates) as an argument to the
            task.
 
         5. Generate the revision/release objects for the given version. From
            the data generated at steps 3 and 4.
 
         end for each
 
         6. Generate and load the snapshot for the visit
 
         Using the revisions/releases collected at step 5., and the branch
         information from step 0., generate a snapshot and load it into the
         Software Heritage archive
 
         """
         status_load = 'uneventful'  # either: eventful, uneventful, failed
         status_visit = 'full'       # either: partial, full
         tmp_revisions = {}  # type: Dict[str, List]
         snapshot = None
 
+        def finalize_visit() -> Dict[str, Any]:
+            """Finalize the visit:
+
+            - flush eventual unflushed data to storage
+            - update origin visit's status
+            - return the task's status
+
+            """
+            if hasattr(self.storage, 'flush'):
+                self.storage.flush()
+            self.storage.origin_visit_update(
+                origin=self.url, visit_id=visit.visit, status=status_visit,
+                snapshot=snapshot and snapshot.id)
+
+            result: Dict[str, Any] = {
+                'status': status_load,
+            }
+            if snapshot:
+                result['snapshot_id'] = hash_to_hex(snapshot.id)
+            return result
+
         # Prepare origin and origin_visit
         origin = Origin(url=self.url)
         try:
             self.storage.origin_add_one(origin)
             visit = self.storage.origin_visit_add(
                 self.url, date=self.visit_date, type=self.visit_type)
-        except Exception:
-            logger.exception('Failed to create origin/origin_visit:')
+        except Exception as e:
+            logger.exception('Failed to initialize origin_visit for %s',
+                             self.url)
+            sentry_sdk.capture_exception(e)
             return {'status': 'failed'}
 
         try:
             last_snapshot = self.last_snapshot()
             logger.debug('last snapshot: %s', last_snapshot)
             known_artifacts = self.known_artifacts(last_snapshot)
             logger.debug('known artifacts: %s', known_artifacts)
+        except Exception as e:
+            logger.exception('Failed to get previous state for %s', self.url)
+            sentry_sdk.capture_exception(e)
+            status_visit = 'partial'
+            status_load = 'failed'
+            return finalize_visit()
+
+        load_exceptions = []
+
+        for version in self.get_versions():  # for each
+            logger.debug('version: %s', version)
+            tmp_revisions[version] = []
+            # `p_` stands for `package_`
+            for branch_name, p_info in self.get_package_info(version):
+                logger.debug('package_info: %s', p_info)
+                revision_id = self.resolve_revision_from(
+                    known_artifacts, p_info['raw'])
+                if revision_id is None:
+                    try:
+                        revision_id = self._load_revision(p_info, origin)
+                        status_load = 'eventful'
+                    except Exception as e:
+                        load_exceptions.append(e)
+                        sentry_sdk.capture_exception(e)
+                        logger.exception('Failed loading branch %s for %s',
+                                         branch_name, self.url)
+                        continue
 
-            for version in self.get_versions():  # for each
-                logger.debug('version: %s', version)
-                tmp_revisions[version] = []
-                # `p_` stands for `package_`
-                for branch_name, p_info in self.get_package_info(version):
-                    logger.debug('package_info: %s', p_info)
-                    revision_id = self.resolve_revision_from(
-                        known_artifacts, p_info['raw'])
                     if revision_id is None:
-                        (revision_id, loaded) = \
-                            self._load_revision(p_info, origin)
-                        if loaded:
-                            status_load = 'eventful'
-                        else:
-                            status_visit = 'partial'
-                        if revision_id is None:
-                            continue
-
-                    tmp_revisions[version].append((branch_name, revision_id))
-
-        except Exception:
-            logger.exception('Fail to load %s' % self.url)
+                        continue
+
+                tmp_revisions[version].append((branch_name, revision_id))
+
+        if load_exceptions:
             status_visit = 'partial'
+
+        if not tmp_revisions:
+            # We could not load any revisions; fail completely
+            status_visit = 'failed'
             status_load = 'failed'
-        finally:
+            return finalize_visit()
+
+        try:
             # Retrieve the default release version (the "latest" one)
             default_version = self.get_default_version()
             logger.debug('default version: %s', default_version)
+            # Retrieve extra branches
             extra_branches = self.extra_branches()
             logger.debug('extra branches: %s', extra_branches)
-            snapshot = self._load_snapshot(
-                default_version, tmp_revisions, extra_branches)
-            if hasattr(self.storage, 'flush'):
-                self.storage.flush()
-            self.storage.origin_visit_update(
-                origin=self.url, visit_id=visit.visit, status=status_visit,
-                snapshot=snapshot and snapshot.id)
-        result: Dict[str, Any] = {
-            'status': status_load,
-        }
-        if snapshot:
-            result['snapshot_id'] = hash_to_hex(snapshot.id)
-        return result
 
-    def _load_revision(self, p_info, origin) -> Tuple[Optional[Sha1Git], bool]:
+            snapshot = self._load_snapshot(default_version, tmp_revisions,
+                                           extra_branches)
+
+        except Exception as e:
+            logger.exception('Failed to build snapshot for origin %s',
+                             self.url)
+            sentry_sdk.capture_exception(e)
+            status_visit = 'partial'
+            status_load = 'failed'
+
+        return finalize_visit()
+
+    def _load_revision(self, p_info, origin) -> Optional[Sha1Git]:
         """Does all the loading of a revision itself:
 
         * downloads a package and uncompresses it
         * loads it from disk
         * adds contents, directories, and revision to self.storage
         * returns (revision_id, loaded)
+
+        Raises
+            exception when unable to download or uncompress artifacts
+
         """
         with tempfile.TemporaryDirectory() as tmpdir:
-            try:
-                dl_artifacts = self.download_package(p_info, tmpdir)
-            except Exception:
-                logger.exception('Unable to retrieve %s',
-                                 p_info)
-                return (None, False)
-
-            try:
-                uncompressed_path = self.uncompress(dl_artifacts, dest=tmpdir)
-                logger.debug('uncompressed_path: %s', uncompressed_path)
-            except ValueError:
-                logger.exception('Fail to uncompress %s',
-                                 p_info['url'])
-                return (None, False)
+            dl_artifacts = self.download_package(p_info, tmpdir)
+
+            uncompressed_path = self.uncompress(dl_artifacts, dest=tmpdir)
+            logger.debug('uncompressed_path: %s', uncompressed_path)
 
             directory = from_disk.Directory.from_disk(
                 path=uncompressed_path.encode('utf-8'),
                 max_content_length=self.max_content_size)
 
             contents: List[Content] = []
             skipped_contents: List[SkippedContent] = []
             directories: List[Directory] = []
 
             for obj in directory.iter_tree():
                 obj = obj.to_model()
                 if isinstance(obj, Content):
                     # FIXME: read the data from disk later (when the
                     # storage buffer is flushed).
                     obj = obj.with_data()
                     contents.append(obj)
                 elif isinstance(obj, SkippedContent):
                     skipped_contents.append(obj)
                 elif isinstance(obj, Directory):
                     directories.append(obj)
                 else:
                     raise TypeError(
                         f'Unexpected content type from disk: {obj}')
 
             logger.debug('Number of skipped contents: %s',
                          len(skipped_contents))
             self.storage.skipped_content_add(skipped_contents)
             logger.debug('Number of contents: %s', len(contents))
             self.storage.content_add(contents)
 
             logger.debug('Number of directories: %s', len(directories))
             self.storage.directory_add(directories)
 
             # FIXME: This should be release. cf. D409
             revision = self.build_revision(
                 p_info['raw'], uncompressed_path, directory=directory.hash)
             if not revision:
                 # Some artifacts are missing intrinsic metadata
                 # skipping those
-                return (None, True)
+                return None
 
         metadata = revision.metadata or {}
         metadata.update({
             'original_artifact': [
                 hashes for _, hashes in dl_artifacts
             ],
         })
         revision = attr.evolve(revision, metadata=metadata)
 
         logger.debug('Revision: %s', revision)
 
         self.storage.revision_add([revision])
 
-        return (revision.id, True)
+        return revision.id
 
     def _load_snapshot(
             self, default_version: str,
             revisions: Dict[str, List[Tuple[str, bytes]]],
             extra_branches: Dict[bytes, Mapping[str, Any]]
     ) -> Optional[Snapshot]:
         """Build snapshot out of the current revisions stored and extra branches.
            Then load it in the storage.
 
         """
         logger.debug('revisions: %s', revisions)
         # Build and load the snapshot
         branches = {}  # type: Dict[bytes, Mapping[str, Any]]
         for version, branch_name_revisions in revisions.items():
             if version == default_version and \
                len(branch_name_revisions) == 1:
                 # only 1 branch (no ambiguity), we can create an alias
                 # branch 'HEAD'
                 branch_name, _ = branch_name_revisions[0]
                 # except for some corner case (deposit)
                 if branch_name != 'HEAD':
                     branches[b'HEAD'] = {
                         'target_type': 'alias',
                         'target': branch_name.encode('utf-8'),
                     }
 
             for branch_name, target in branch_name_revisions:
                 branches[branch_name.encode('utf-8')] = {
                     'target_type': 'revision',
                     'target': target,
                 }
 
         # Deal with extra-branches
         for name, branch_target in extra_branches.items():
             if name in branches:
                 logger.error("Extra branch '%s' has been ignored",
                              name)
             else:
                 branches[name] = branch_target
 
         snapshot_data = {
             'branches': branches
         }
         logger.debug('snapshot: %s', snapshot_data)
         snapshot = Snapshot.from_dict(snapshot_data)
         logger.debug('snapshot: %s', snapshot)
         self.storage.snapshot_add([snapshot])
 
         return snapshot
diff --git a/swh/loader/package/npm/tests/test_npm.py b/swh/loader/package/npm/tests/test_npm.py
index be6dd05..687ffaa 100644
--- a/swh/loader/package/npm/tests/test_npm.py
+++ b/swh/loader/package/npm/tests/test_npm.py
@@ -1,591 +1,591 @@
 # Copyright (C) 2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import json
 import os
 import pytest
 
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import Person
 
 from swh.loader.package.npm.loader import (
     NpmLoader, extract_npm_package_author,
     artifact_to_revision_id
 )
 from swh.loader.package.tests.common import (
     check_snapshot, check_metadata_paths, get_stats
 )
 
 
 def test_extract_npm_package_author(datadir):
     package_metadata_filepath = os.path.join(
         datadir, 'https_replicate.npmjs.com', 'org_visit1')
 
     with open(package_metadata_filepath) as json_file:
         package_metadata = json.load(json_file)
 
     extract_npm_package_author(package_metadata['versions']['0.0.2']) == \
         Person(
             fullname=b'mooz <stillpedant@gmail.com>',
             name=b'mooz',
             email=b'stillpedant@gmail.com'
         )
 
     assert (
         extract_npm_package_author(package_metadata['versions']['0.0.3']) ==
         Person(
             fullname=b'Masafumi Oyamada <stillpedant@gmail.com>',
             name=b'Masafumi Oyamada',
             email=b'stillpedant@gmail.com'
         )
     )
 
     package_json = json.loads('''
     {
         "name": "highlightjs-line-numbers.js",
         "version": "2.7.0",
         "description": "Highlight.js line numbers plugin.",
         "main": "src/highlightjs-line-numbers.js",
         "dependencies": {},
         "devDependencies": {
             "gulp": "^4.0.0",
             "gulp-rename": "^1.4.0",
             "gulp-replace": "^0.6.1",
             "gulp-uglify": "^1.2.0"
         },
         "repository": {
             "type": "git",
             "url": "https://github.com/wcoder/highlightjs-line-numbers.js.git"
         },
         "author": "Yauheni Pakala <evgeniy.pakalo@gmail.com>",
         "license": "MIT",
         "bugs": {
             "url": "https://github.com/wcoder/highlightjs-line-numbers.js/issues"
         },
         "homepage": "http://wcoder.github.io/highlightjs-line-numbers.js/"
     }''') # noqa
 
     assert extract_npm_package_author(package_json) == \
         Person(
             fullname=b'Yauheni Pakala <evgeniy.pakalo@gmail.com>',
             name=b'Yauheni Pakala',
             email=b'evgeniy.pakalo@gmail.com'
         )
 
     package_json = json.loads('''
     {
         "name": "3-way-diff",
         "version": "0.0.1",
         "description": "3-way diffing of JavaScript objects",
         "main": "index.js",
         "authors": [
             {
                 "name": "Shawn Walsh",
                 "url": "https://github.com/shawnpwalsh"
             },
             {
                 "name": "Markham F Rollins IV",
                 "url": "https://github.com/mrollinsiv"
             }
         ],
         "keywords": [
             "3-way diff",
             "3 way diff",
             "three-way diff",
             "three way diff"
         ],
         "devDependencies": {
             "babel-core": "^6.20.0",
             "babel-preset-es2015": "^6.18.0",
             "mocha": "^3.0.2"
         },
         "dependencies": {
             "lodash": "^4.15.0"
         }
     }''')
 
     assert extract_npm_package_author(package_json) == \
         Person(
             fullname=b'Shawn Walsh',
             name=b'Shawn Walsh',
             email=None
         )
 
     package_json = json.loads('''
     {
         "name": "yfe-ynpm",
         "version": "1.0.0",
         "homepage": "http://gitlab.ywwl.com/yfe/yfe-ynpm",
         "repository": {
             "type": "git",
             "url": "git@gitlab.ywwl.com:yfe/yfe-ynpm.git"
         },
         "author": [
             "fengmk2 <fengmk2@gmail.com> (https://fengmk2.com)",
             "xufuzi <xufuzi@ywwl.com> (https://7993.org)"
         ],
         "license": "MIT"
     }''')
 
     assert extract_npm_package_author(package_json) == \
         Person(
             fullname=b'fengmk2 <fengmk2@gmail.com> (https://fengmk2.com)',
             name=b'fengmk2',
             email=b'fengmk2@gmail.com',
         )
 
     package_json = json.loads('''
     {
         "name": "umi-plugin-whale",
         "version": "0.0.8",
         "description": "Internal contract component",
         "authors": {
             "name": "xiaohuoni",
             "email": "448627663@qq.com"
         },
         "repository": "alitajs/whale",
         "devDependencies": {
             "np": "^3.0.4",
             "umi-tools": "*"
         },
         "license": "MIT"
     }''')
 
     assert extract_npm_package_author(package_json) == \
         Person(
             fullname=b'xiaohuoni <448627663@qq.com>',
             name=b'xiaohuoni',
             email=b'448627663@qq.com'
         )
 
 
 def normalize_hashes(hashes):
     if isinstance(hashes, str):
         return hash_to_bytes(hashes)
     if isinstance(hashes, list):
         return [hash_to_bytes(x) for x in hashes]
     return {hash_to_bytes(k): hash_to_bytes(v) for k, v in hashes.items()}
 
 
 _expected_new_contents_first_visit = normalize_hashes([
     '4ce3058e16ab3d7e077f65aabf855c34895bf17c',
     '858c3ceee84c8311adc808f8cdb30d233ddc9d18',
     '0fa33b4f5a4e0496da6843a38ff1af8b61541996',
     '85a410f8ef8eb8920f2c384a9555566ad4a2e21b',
     '9163ac8025923d5a45aaac482262893955c9b37b',
     '692cf623b8dd2c5df2c2998fd95ae4ec99882fb4',
     '18c03aac6d3e910efb20039c15d70ab5e0297101',
     '41265c42446aac17ca769e67d1704f99e5a1394d',
     '783ff33f5882813dca9239452c4a7cadd4dba778',
     'b029cfb85107aee4590c2434a3329bfcf36f8fa1',
     '112d1900b4c2e3e9351050d1b542c9744f9793f3',
     '5439bbc4bd9a996f1a38244e6892b71850bc98fd',
     'd83097a2f994b503185adf4e719d154123150159',
     'd0939b4898e83090ee55fd9d8a60e312cfadfbaf',
     'b3523a26f7147e4af40d9d462adaae6d49eda13e',
     'cd065fb435d6fb204a8871bcd623d0d0e673088c',
     '2854a40855ad839a54f4b08f5cff0cf52fca4399',
     'b8a53bbaac34ebb8c6169d11a4b9f13b05c583fe',
     '0f73d56e1cf480bded8a1ecf20ec6fc53c574713',
     '0d9882b2dfafdce31f4e77fe307d41a44a74cefe',
     '585fc5caab9ead178a327d3660d35851db713df1',
     'e8cd41a48d79101977e3036a87aeb1aac730686f',
     '5414efaef33cceb9f3c9eb5c4cc1682cd62d14f7',
     '9c3cc2763bf9e9e37067d3607302c4776502df98',
     '3649a68410e354c83cd4a38b66bd314de4c8f5c9',
     'e96ed0c091de1ebdf587104eaf63400d1974a1fe',
     '078ca03d2f99e4e6eab16f7b75fbb7afb699c86c',
     '38de737da99514de6559ff163c988198bc91367a',
 ])
 
 _expected_new_directories_first_visit = normalize_hashes([
     '3370d20d6f96dc1c9e50f083e2134881db110f4f',
     '42753c0c2ab00c4501b552ac4671c68f3cf5aece',
     'd7895533ef5edbcffdea3f057d9fef3a1ef845ce',
     '80579be563e2ef3e385226fe7a3f079b377f142c',
     '3b0ddc6a9e58b4b53c222da4e27b280b6cda591c',
     'bcad03ce58ac136f26f000990fc9064e559fe1c0',
     '5fc7e82a1bc72e074665c6078c6d3fad2f13d7ca',
     'e3cd26beba9b1e02f6762ef54bd9ac80cc5f25fd',
     '584b5b4b6cf7f038095e820b99386a9c232de931',
     '184c8d6d0d242f2b1792ef9d3bf396a5434b7f7a',
     'bb5f4ee143c970367eb409f2e4c1104898048b9d',
     '1b95491047add1103db0dfdfa84a9735dcb11e88',
     'a00c6de13471a2d66e64aca140ddb21ef5521e62',
     '5ce6c1cd5cda2d546db513aaad8c72a44c7771e2',
     'c337091e349b6ac10d38a49cdf8c2401ef9bb0f2',
     '202fafcd7c0f8230e89d5496ad7f44ab12b807bf',
     '775cc516543be86c15c1dc172f49c0d4e6e78235',
     'ff3d1ead85a14f891e8b3fa3a89de39db1b8de2e',
 ])
 
 _expected_new_revisions_first_visit = normalize_hashes({
     'd8a1c7474d2956ac598a19f0f27d52f7015f117e':
     '42753c0c2ab00c4501b552ac4671c68f3cf5aece',
     '5f9eb78af37ffd12949f235e86fac04898f9f72a':
     '3370d20d6f96dc1c9e50f083e2134881db110f4f',
     'ba019b192bdb94bd0b5bd68b3a5f92b5acc2239a':
     'd7895533ef5edbcffdea3f057d9fef3a1ef845ce'}
 )
 
 
 def package_url(package):
     return 'https://www.npmjs.com/package/%s' % package
 
 
 def package_metadata_url(package):
     return 'https://replicate.npmjs.com/%s/' % package
 
 
 def test_revision_metadata_structure(swh_config, requests_mock_datadir):
     package = 'org'
     loader = NpmLoader(package_url(package))
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'eventful'
     assert actual_load_status['snapshot_id'] is not None
 
     expected_revision_id = hash_to_bytes(
         'd8a1c7474d2956ac598a19f0f27d52f7015f117e')
     revision = list(loader.storage.revision_get([expected_revision_id]))[0]
 
     assert revision is not None
 
     check_metadata_paths(revision['metadata'], paths=[
         ('intrinsic.tool', str),
         ('intrinsic.raw', dict),
         ('extrinsic.provider', str),
         ('extrinsic.when', str),
         ('extrinsic.raw', dict),
         ('original_artifact', list),
     ])
 
     for original_artifact in revision['metadata']['original_artifact']:
         check_metadata_paths(original_artifact, paths=[
             ('filename', str),
             ('length', int),
             ('checksums', dict),
         ])
 
 
 def test_npm_loader_first_visit(swh_config, requests_mock_datadir):
 
     package = 'org'
     loader = NpmLoader(package_url(package))
 
     actual_load_status = loader.load()
     expected_snapshot_id = 'd0587e1195aed5a8800411a008f2f2d627f18e2d'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id
     }
 
     stats = get_stats(loader.storage)
 
     assert {
         'content': len(_expected_new_contents_first_visit),
         'directory': len(_expected_new_directories_first_visit),
         'origin': 1,
         'origin_visit': 1,
         'person': 2,
         'release': 0,
         'revision': len(_expected_new_revisions_first_visit),
         'skipped_content': 0,
         'snapshot': 1,
     } == stats
 
     assert len(list(loader.storage.content_get(
         _expected_new_contents_first_visit))) == len(
             _expected_new_contents_first_visit)
 
     assert list(loader.storage.directory_missing(
         _expected_new_directories_first_visit)) == []
 
     assert list(loader.storage.revision_missing(
         _expected_new_revisions_first_visit)) == []
 
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': {
             'HEAD': {
                 'target': 'releases/0.0.4',
                 'target_type': 'alias'
             },
             'releases/0.0.2': {
                 'target': 'd8a1c7474d2956ac598a19f0f27d52f7015f117e',
                 'target_type': 'revision'
             },
             'releases/0.0.3': {
                 'target': '5f9eb78af37ffd12949f235e86fac04898f9f72a',
                 'target_type': 'revision'
             },
             'releases/0.0.4': {
                 'target': 'ba019b192bdb94bd0b5bd68b3a5f92b5acc2239a',
                 'target_type': 'revision'
             }
         }
     }
     check_snapshot(expected_snapshot, loader.storage)
 
 
 def test_npm_loader_incremental_visit(
         swh_config, requests_mock_datadir_visits):
     package = 'org'
     url = package_url(package)
     loader = NpmLoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'eventful'
     assert actual_load_status['status'] is not None
     origin_visit = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'npm'
 
     stats = get_stats(loader.storage)
 
     assert {
         'content': len(_expected_new_contents_first_visit),
         'directory': len(_expected_new_directories_first_visit),
         'origin': 1,
         'origin_visit': 1,
         'person': 2,
         'release': 0,
         'revision': len(_expected_new_revisions_first_visit),
         'skipped_content': 0,
         'snapshot': 1,
     } == stats
 
     loader._info = None  # reset loader internal state
     actual_load_status2 = loader.load()
     assert actual_load_status2['status'] == 'eventful'
     snap_id2 = actual_load_status2['snapshot_id']
     assert snap_id2 is not None
     assert snap_id2 != actual_load_status['snapshot_id']
 
     origin_visit2 = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit2['status'] == 'full'
     assert origin_visit2['type'] == 'npm'
 
     stats = get_stats(loader.storage)
 
     assert {  # 3 new releases artifacts
         'content': len(_expected_new_contents_first_visit) + 14,
         'directory': len(_expected_new_directories_first_visit) + 15,
         'origin': 1,
         'origin_visit': 2,
         'person': 2,
         'release': 0,
         'revision': len(_expected_new_revisions_first_visit) + 3,
         'skipped_content': 0,
         'snapshot': 2,
     } == stats
 
     urls = [
         m.url for m in requests_mock_datadir_visits.request_history
         if m.url.startswith('https://registry.npmjs.org')
     ]
     assert len(urls) == len(set(urls))  # we visited each artifact once across
 
 
 @pytest.mark.usefixtures('requests_mock_datadir')
 def test_npm_loader_version_divergence(swh_config):
     package = '@aller_shared'
     url = package_url(package)
     loader = NpmLoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'eventful'
     assert actual_load_status['status'] is not None
     origin_visit = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'npm'
 
     stats = get_stats(loader.storage)
 
     assert {  # 1 new releases artifacts
         'content': 534,
         'directory': 153,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 2,
         'skipped_content': 0,
         'snapshot': 1,
     } == stats
 
     expected_snapshot = {
         'id': 'b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92',
         'branches': {
             'HEAD': {
                 'target_type': 'alias',
                 'target': 'releases/0.1.0'
             },
             'releases/0.1.0': {
                 'target_type': 'revision',
                 'target': '845673bfe8cbd31b1eaf757745a964137e6f9116',
             },
             'releases/0.1.1-alpha.14': {
                 'target_type': 'revision',
                 'target': '05181c12cd8c22035dd31155656826b85745da37',
             },
         },
     }
     check_snapshot(expected_snapshot, loader.storage)
 
 
 def test_npm_artifact_to_revision_id_none():
     """Current loader version should stop soon if nothing can be found
 
     """
     artifact_metadata = {
         'dist': {
             'shasum': '05181c12cd8c22035dd31155656826b85745da37',
         },
     }
 
     known_artifacts = {
         'b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92': {},
     }
 
     assert artifact_to_revision_id(known_artifacts, artifact_metadata) is None
 
 
 def test_npm_artifact_to_revision_id_old_loader_version():
     """Current loader version should solve old metadata scheme
 
     """
     artifact_metadata = {
         'dist': {
             'shasum': '05181c12cd8c22035dd31155656826b85745da37',
         }
     }
 
     known_artifacts = {
         hash_to_bytes('b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92'): {
             'package_source': {
                 'sha1': "something-wrong"
             }
         },
         hash_to_bytes('845673bfe8cbd31b1eaf757745a964137e6f9116'): {
             'package_source': {
                 'sha1': '05181c12cd8c22035dd31155656826b85745da37',
             }
         }
 
     }
 
     assert artifact_to_revision_id(known_artifacts, artifact_metadata) \
         == hash_to_bytes('845673bfe8cbd31b1eaf757745a964137e6f9116')
 
 
 def test_npm_artifact_to_revision_id_current_loader_version():
     """Current loader version should be able to solve current metadata scheme
 
     """
     artifact_metadata = {
         'dist': {
             'shasum': '05181c12cd8c22035dd31155656826b85745da37',
         }
     }
 
     known_artifacts = {
         hash_to_bytes('b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92'): {
             'original_artifact': [{
                 'checksums': {
                     'sha1': "05181c12cd8c22035dd31155656826b85745da37"
                 },
             }],
         },
         hash_to_bytes('845673bfe8cbd31b1eaf757745a964137e6f9116'): {
             'original_artifact': [{
                 'checksums': {
                     'sha1': 'something-wrong'
                 },
             }],
         },
     }
 
     assert artifact_to_revision_id(known_artifacts, artifact_metadata) \
         == hash_to_bytes('b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92')
 
 
 def test_npm_artifact_with_no_intrinsic_metadata(
         swh_config, requests_mock_datadir):
     """Skip artifact with no intrinsic metadata during ingestion
 
     """
     package = 'nativescript-telerik-analytics'
     url = package_url(package)
     loader = NpmLoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'eventful'
 
     # no branch as one artifact without any intrinsic metadata
     expected_snapshot = {
         'id': '1a8893e6a86f444e8be8e7bda6cb34fb1735a00e',
         'branches': {},
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'npm'
 
 
 def test_npm_artifact_with_no_upload_time(swh_config, requests_mock_datadir):
     """With no time upload, artifact is skipped
 
     """
     package = 'jammit-no-time'
     url = package_url(package)
     loader = NpmLoader(url)
 
     actual_load_status = loader.load()
-    assert actual_load_status['status'] == 'failed'
+    assert actual_load_status['status'] == 'uneventful'
 
     # no branch as one artifact without any intrinsic metadata
     expected_snapshot = {
         'id': '1a8893e6a86f444e8be8e7bda6cb34fb1735a00e',
         'branches': {},
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit['status'] == 'partial'
     assert origin_visit['type'] == 'npm'
 
 
 def test_npm_artifact_use_mtime_if_no_time(swh_config, requests_mock_datadir):
     """With no time upload, artifact is skipped
 
     """
     package = 'jammit-express'
     url = package_url(package)
     loader = NpmLoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'eventful'
 
     # artifact is used
     expected_snapshot = {
         'id': 'd6e08e19159f77983242877c373c75222d5ae9dd',
         'branches': {
             'HEAD': {
                 'target_type': 'alias',
                 'target': 'releases/0.0.1'
             },
             'releases/0.0.1': {
                 'target_type': 'revision',
                 'target': '9e4dd2b40d1b46b70917c0949aa2195c823a648e',
             }
         }
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'npm'
diff --git a/swh/loader/package/pypi/tests/test_pypi.py b/swh/loader/package/pypi/tests/test_pypi.py
index 7f68b1d..6979813 100644
--- a/swh/loader/package/pypi/tests/test_pypi.py
+++ b/swh/loader/package/pypi/tests/test_pypi.py
@@ -1,836 +1,834 @@
 # Copyright (C) 2019-2020 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import os
 
 from os import path
 
 import pytest
 
 from unittest.mock import patch
 
 from swh.core.tarball import uncompress
 from swh.core.pytest_plugin import requests_mock_datadir_factory
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import Person
 
 from swh.loader.package.pypi.loader import (
     PyPILoader, pypi_api_url, author, extract_intrinsic_metadata,
     artifact_to_revision_id
 )
 from swh.loader.package.tests.common import (
     check_snapshot, check_metadata_paths, get_stats
 )
 
 
 def test_author_basic():
     data = {
         'author': "i-am-groot",
         'author_email': 'iam@groot.org',
     }
     actual_author = author(data)
 
     expected_author = Person(
         fullname=b'i-am-groot <iam@groot.org>',
         name=b'i-am-groot',
         email=b'iam@groot.org',
     )
 
     assert actual_author == expected_author
 
 
 def test_author_empty_email():
     data = {
         'author': 'i-am-groot',
         'author_email': '',
     }
     actual_author = author(data)
 
     expected_author = Person(
         fullname=b'i-am-groot',
         name=b'i-am-groot',
         email=b'',
     )
 
     assert actual_author == expected_author
 
 
 def test_author_empty_name():
     data = {
         'author': "",
         'author_email': 'iam@groot.org',
     }
     actual_author = author(data)
 
     expected_author = Person(
         fullname=b' <iam@groot.org>',
         name=b'',
         email=b'iam@groot.org',
     )
 
     assert actual_author == expected_author
 
 
 def test_author_malformed():
     data = {
         'author': "['pierre', 'paul', 'jacques']",
         'author_email': None,
     }
 
     actual_author = author(data)
 
     expected_author = Person(
         fullname=b"['pierre', 'paul', 'jacques']",
         name=b"['pierre', 'paul', 'jacques']",
         email=None,
     )
 
     assert actual_author == expected_author
 
 
 def test_author_malformed_2():
     data = {
         'author': '[marie, jeanne]',
         'author_email': '[marie@some, jeanne@thing]',
     }
 
     actual_author = author(data)
 
     expected_author = Person(
         fullname=b'[marie, jeanne] <[marie@some, jeanne@thing]>',
         name=b'[marie, jeanne]',
         email=b'[marie@some, jeanne@thing]',
     )
 
     assert actual_author == expected_author
 
 
 def test_author_malformed_3():
     data = {
         'author': '[marie, jeanne, pierre]',
         'author_email': '[marie@somewhere.org, jeanne@somewhere.org]',
     }
 
     actual_author = author(data)
 
     expected_author = Person(
         fullname=(
             b'[marie, jeanne, pierre] '
             b'<[marie@somewhere.org, jeanne@somewhere.org]>'
         ),
         name=b'[marie, jeanne, pierre]',
         email=b'[marie@somewhere.org, jeanne@somewhere.org]',
     )
 
     actual_author == expected_author
 
 
 # configuration error #
 
 def test_badly_configured_loader_raise(monkeypatch):
     """Badly configured loader should raise"""
     monkeypatch.delenv('SWH_CONFIG_FILENAME', raising=False)
     with pytest.raises(ValueError) as e:
         PyPILoader(url='some-url')
 
     assert 'Misconfiguration' in e.value.args[0]
 
 
 def test_pypi_api_url():
     """Compute pypi api url from the pypi project url should be ok"""
     url = pypi_api_url('https://pypi.org/project/requests')
     assert url == 'https://pypi.org/pypi/requests/json'
 
 
 def test_pypi_api_url_with_slash():
     """Compute pypi api url from the pypi project url should be ok"""
     url = pypi_api_url('https://pypi.org/project/requests/')
     assert url == 'https://pypi.org/pypi/requests/json'
 
 
 @pytest.mark.fs
 def test_extract_intrinsic_metadata(tmp_path, datadir):
     """Parsing existing archive's PKG-INFO should yield results"""
     uncompressed_archive_path = str(tmp_path)
     archive_path = path.join(
         datadir, 'https_files.pythonhosted.org', '0805nexter-1.1.0.zip')
     uncompress(archive_path, dest=uncompressed_archive_path)
 
     actual_metadata = extract_intrinsic_metadata(uncompressed_archive_path)
     expected_metadata = {
         'metadata_version': '1.0',
         'name': '0805nexter',
         'version': '1.1.0',
         'summary': 'a simple printer of nested lest',
         'home_page': 'http://www.hp.com',
         'author': 'hgtkpython',
         'author_email': '2868989685@qq.com',
         'platforms': ['UNKNOWN'],
     }
 
     assert actual_metadata == expected_metadata
 
 
 @pytest.mark.fs
 def test_extract_intrinsic_metadata_failures(tmp_path):
     """Parsing inexistent path/archive/PKG-INFO yield None"""
     tmp_path = str(tmp_path)  # py3.5 work around (PosixPath issue)
     # inexistent first level path
     assert extract_intrinsic_metadata('/something-inexistent') == {}
     # inexistent second level path (as expected by pypi archives)
     assert extract_intrinsic_metadata(tmp_path) == {}
     # inexistent PKG-INFO within second level path
     existing_path_no_pkginfo = path.join(tmp_path, 'something')
     os.mkdir(existing_path_no_pkginfo)
     assert extract_intrinsic_metadata(tmp_path) == {}
 
 
 # LOADER SCENARIO #
 
 # "edge" cases (for the same origin) #
 
 
 # no release artifact:
 # {visit full, status: uneventful, no contents, etc...}
 requests_mock_datadir_missing_all = requests_mock_datadir_factory(ignore_urls=[
     'https://files.pythonhosted.org/packages/ec/65/c0116953c9a3f47de89e71964d6c7b0c783b01f29fa3390584dbf3046b4d/0805nexter-1.1.0.zip',  # noqa
     'https://files.pythonhosted.org/packages/c4/a0/4562cda161dc4ecbbe9e2a11eb365400c0461845c5be70d73869786809c4/0805nexter-1.2.0.zip',  # noqa
 ])
 
 
 def test_no_release_artifact(swh_config, requests_mock_datadir_missing_all):
     """Load a pypi project with all artifacts missing ends up with no snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'uneventful'
     assert actual_load_status['snapshot_id'] is not None
 
     stats = get_stats(loader.storage)
     assert {
         'content': 0,
         'directory': 0,
         'origin': 1,
         'origin_visit': 1,
         'person': 0,
         'release': 0,
         'revision': 0,
         'skipped_content': 0,
         'snapshot': 1,
     } == stats
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'partial'
     assert origin_visit['type'] == 'pypi'
 
 
 # problem during loading:
 # {visit: partial, status: uneventful, no snapshot}
 
 
 def test_release_with_traceback(swh_config, requests_mock_datadir):
     url = 'https://pypi.org/project/0805nexter'
     with patch('swh.loader.package.pypi.loader.PyPILoader.last_snapshot',
                side_effect=ValueError('Fake problem to fail the visit')):
         loader = PyPILoader(url)
 
         actual_load_status = loader.load()
-        assert actual_load_status['status'] == 'failed'
-        assert actual_load_status[
-            'snapshot_id'] == '1a8893e6a86f444e8be8e7bda6cb34fb1735a00e'
+        assert actual_load_status == {'status': 'failed'}
 
         stats = get_stats(loader.storage)
 
         assert {
             'content': 0,
             'directory': 0,
             'origin': 1,
             'origin_visit': 1,
             'person': 0,
             'release': 0,
             'revision': 0,
             'skipped_content': 0,
-            'snapshot': 1,
+            'snapshot': 0,
         } == stats
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'partial'
     assert origin_visit['type'] == 'pypi'
 
 
 # problem during loading: failure early enough in between swh contents...
 # some contents (contents, directories, etc...) have been written in storage
 # {visit: partial, status: eventful, no snapshot}
 
 # problem during loading: failure late enough we can have snapshots (some
 # revisions are written in storage already)
 # {visit: partial, status: eventful, snapshot}
 
 # "normal" cases (for the same origin) #
 
 
 requests_mock_datadir_missing_one = requests_mock_datadir_factory(ignore_urls=[
     'https://files.pythonhosted.org/packages/ec/65/c0116953c9a3f47de89e71964d6c7b0c783b01f29fa3390584dbf3046b4d/0805nexter-1.1.0.zip',  # noqa
 ])
 
 # some missing release artifacts:
 # {visit partial, status: eventful, 1 snapshot}
 
 
 def test_revision_metadata_structure(swh_config, requests_mock_datadir):
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'eventful'
     assert actual_load_status['snapshot_id'] is not None
 
     expected_revision_id = hash_to_bytes(
         'e445da4da22b31bfebb6ffc4383dbf839a074d21')
     revision = list(loader.storage.revision_get([expected_revision_id]))[0]
 
     assert revision is not None
 
     check_metadata_paths(revision['metadata'], paths=[
         ('intrinsic.tool', str),
         ('intrinsic.raw', dict),
         ('extrinsic.provider', str),
         ('extrinsic.when', str),
         ('extrinsic.raw', dict),
         ('original_artifact', list),
     ])
 
     for original_artifact in revision['metadata']['original_artifact']:
         check_metadata_paths(original_artifact, paths=[
             ('filename', str),
             ('length', int),
             ('checksums', dict),
         ])
 
 
 def test_visit_with_missing_artifact(
         swh_config, requests_mock_datadir_missing_one):
     """Load a pypi project with some missing artifacts ends up with 1 snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = 'dd0e4201a232b1c104433741dbf45895b8ac9355'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id
     }
 
     stats = get_stats(loader.storage)
 
     assert {
         'content': 3,
         'directory': 2,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 1,
         'skipped_content': 0,
         'snapshot': 1
     } == stats
 
     expected_contents = map(hash_to_bytes, [
         '405859113963cb7a797642b45f171d6360425d16',
         'e5686aa568fdb1d19d7f1329267082fe40482d31',
         '83ecf6ec1114fd260ca7a833a2d165e71258c338',
     ])
 
     assert list(loader.storage.content_missing_per_sha1(expected_contents))\
         == []
 
     expected_dirs = map(hash_to_bytes, [
         'b178b66bd22383d5f16f4f5c923d39ca798861b4',
         'c3a58f8b57433a4b56caaa5033ae2e0931405338',
     ])
 
     assert list(loader.storage.directory_missing(expected_dirs)) == []
 
     # {revision hash: directory hash}
     expected_revs = {
         hash_to_bytes('e445da4da22b31bfebb6ffc4383dbf839a074d21'): hash_to_bytes('b178b66bd22383d5f16f4f5c923d39ca798861b4'),  # noqa
     }
     assert list(loader.storage.revision_missing(expected_revs)) == []
 
     expected_branches = {
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.2.0',
             'target_type': 'alias',
         },
     }
 
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, storage=loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'partial'
     assert origin_visit['type'] == 'pypi'
 
 
 def test_visit_with_1_release_artifact(swh_config, requests_mock_datadir):
     """With no prior visit, load a pypi project ends up with 1 snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = 'ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id
     }
 
     stats = get_stats(loader.storage)
     assert {
         'content': 6,
         'directory': 4,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 2,
         'skipped_content': 0,
         'snapshot': 1
     } == stats
 
     expected_contents = map(hash_to_bytes, [
         'a61e24cdfdab3bb7817f6be85d37a3e666b34566',
         '938c33483285fd8ad57f15497f538320df82aeb8',
         'a27576d60e08c94a05006d2e6d540c0fdb5f38c8',
         '405859113963cb7a797642b45f171d6360425d16',
         'e5686aa568fdb1d19d7f1329267082fe40482d31',
         '83ecf6ec1114fd260ca7a833a2d165e71258c338',
     ])
 
     assert list(loader.storage.content_missing_per_sha1(expected_contents))\
         == []
 
     expected_dirs = map(hash_to_bytes, [
         '05219ba38bc542d4345d5638af1ed56c7d43ca7d',
         'cf019eb456cf6f78d8c4674596f1c9a97ece8f44',
         'b178b66bd22383d5f16f4f5c923d39ca798861b4',
         'c3a58f8b57433a4b56caaa5033ae2e0931405338',
     ])
 
     assert list(loader.storage.directory_missing(expected_dirs)) == []
 
     # {revision hash: directory hash}
     expected_revs = {
         hash_to_bytes('4c99891f93b81450385777235a37b5e966dd1571'): hash_to_bytes('05219ba38bc542d4345d5638af1ed56c7d43ca7d'),  # noqa
         hash_to_bytes('e445da4da22b31bfebb6ffc4383dbf839a074d21'): hash_to_bytes('b178b66bd22383d5f16f4f5c923d39ca798861b4'),  # noqa
     }
     assert list(loader.storage.revision_missing(expected_revs)) == []
 
     expected_branches = {
         'releases/1.1.0': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.2.0',
             'target_type': 'alias',
         },
     }
 
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'
 
 
 def test_multiple_visits_with_no_change(swh_config, requests_mock_datadir):
     """Multiple visits with no changes results in 1 same snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     snapshot_id = 'ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': snapshot_id,
     }
 
     stats = get_stats(loader.storage)
 
     assert {
         'content': 6,
         'directory': 4,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 2,
         'skipped_content': 0,
         'snapshot': 1
     } == stats
 
     expected_branches = {
         'releases/1.1.0': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.2.0',
             'target_type': 'alias',
         },
     }
 
     expected_snapshot = {
         'id': snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'
 
     actual_load_status2 = loader.load()
     assert actual_load_status2 == {
         'status': 'uneventful',
         'snapshot_id': actual_load_status2['snapshot_id']
     }
 
     stats2 = get_stats(loader.storage)
     expected_stats2 = stats.copy()
     expected_stats2['origin_visit'] = 1 + 1
     assert expected_stats2 == stats2
 
     # same snapshot
     actual_snapshot_id = origin_visit['snapshot']
     assert actual_snapshot_id == hash_to_bytes(snapshot_id)
 
 
 def test_incremental_visit(swh_config, requests_mock_datadir_visits):
     """With prior visit, 2nd load will result with a different snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     visit1_actual_load_status = loader.load()
     visit1_stats = get_stats(loader.storage)
     expected_snapshot_id = 'ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a'
     assert visit1_actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id
     }
 
     origin_visit1 = next(loader.storage.origin_visit_get(url))
     assert origin_visit1['status'] == 'full'
     assert origin_visit1['type'] == 'pypi'
 
     assert {
         'content': 6,
         'directory': 4,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 2,
         'skipped_content': 0,
         'snapshot': 1
     } == visit1_stats
 
     # Reset internal state
     loader._info = None
 
     visit2_actual_load_status = loader.load()
     visit2_stats = get_stats(loader.storage)
 
     assert visit2_actual_load_status['status'] == 'eventful'
     expected_snapshot_id2 = '2e5149a7b0725d18231a37b342e9b7c4e121f283'
     assert visit2_actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id2
     }
 
     visits = list(loader.storage.origin_visit_get(url))
     assert len(visits) == 2
     assert visits[1]['status'] == 'full'
     assert visits[1]['type'] == 'pypi'
 
     assert {
         'content': 6 + 1,     # 1 more content
         'directory': 4 + 2,   # 2 more directories
         'origin': 1,
         'origin_visit': 1 + 1,
         'person': 1,
         'release': 0,
         'revision': 2 + 1,    # 1 more revision
         'skipped_content': 0,
         'snapshot': 1 + 1,    # 1 more snapshot
     } == visit2_stats
 
     expected_contents = map(hash_to_bytes, [
         'a61e24cdfdab3bb7817f6be85d37a3e666b34566',
         '938c33483285fd8ad57f15497f538320df82aeb8',
         'a27576d60e08c94a05006d2e6d540c0fdb5f38c8',
         '405859113963cb7a797642b45f171d6360425d16',
         'e5686aa568fdb1d19d7f1329267082fe40482d31',
         '83ecf6ec1114fd260ca7a833a2d165e71258c338',
         '92689fa2b7fb4d4fc6fb195bf73a50c87c030639'
     ])
 
     assert list(loader.storage.content_missing_per_sha1(expected_contents))\
         == []
 
     expected_dirs = map(hash_to_bytes, [
         '05219ba38bc542d4345d5638af1ed56c7d43ca7d',
         'cf019eb456cf6f78d8c4674596f1c9a97ece8f44',
         'b178b66bd22383d5f16f4f5c923d39ca798861b4',
         'c3a58f8b57433a4b56caaa5033ae2e0931405338',
         'e226e7e4ad03b4fc1403d69a18ebdd6f2edd2b3a',
         '52604d46843b898f5a43208045d09fcf8731631b',
 
     ])
 
     assert list(loader.storage.directory_missing(expected_dirs)) == []
 
     # {revision hash: directory hash}
     expected_revs = {
         hash_to_bytes('4c99891f93b81450385777235a37b5e966dd1571'): hash_to_bytes('05219ba38bc542d4345d5638af1ed56c7d43ca7d'),  # noqa
         hash_to_bytes('e445da4da22b31bfebb6ffc4383dbf839a074d21'): hash_to_bytes('b178b66bd22383d5f16f4f5c923d39ca798861b4'),  # noqa
         hash_to_bytes('51247143b01445c9348afa9edfae31bf7c5d86b1'): hash_to_bytes('e226e7e4ad03b4fc1403d69a18ebdd6f2edd2b3a'),  # noqa
     }
 
     assert list(loader.storage.revision_missing(expected_revs)) == []
 
     expected_branches = {
         'releases/1.1.0': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'releases/1.3.0': {
             'target': '51247143b01445c9348afa9edfae31bf7c5d86b1',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.3.0',
             'target_type': 'alias',
         },
     }
     expected_snapshot = {
         'id': expected_snapshot_id2,
         'branches': expected_branches,
     }
 
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'
 
     urls = [
         m.url for m in requests_mock_datadir_visits.request_history
         if m.url.startswith('https://files.pythonhosted.org')
     ]
     # visited each artifact once across 2 visits
     assert len(urls) == len(set(urls))
 
 
 # release artifact, no new artifact
 # {visit full, status uneventful, same snapshot as before}
 
 # release artifact, old artifact with different checksums
 # {visit full, status full, new snapshot with shared history and some new
 # different history}
 
 # release with multiple sdist artifacts per pypi "version"
 # snapshot branch output is different
 
 def test_visit_1_release_with_2_artifacts(swh_config, requests_mock_datadir):
     """With no prior visit, load a pypi project ends up with 1 snapshot
 
     """
     url = 'https://pypi.org/project/nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = 'a27e638a4dad6fbfa273c6ebec1c4bf320fb84c6'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id,
     }
 
     expected_branches = {
         'releases/1.1.0/nexter-1.1.0.zip': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.1.0/nexter-1.1.0.tar.gz': {
             'target': '0bf88f5760cca7665d0af4d6575d9301134fe11a',
             'target_type': 'revision',
         },
     }
 
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'
 
 
 def test_pypi_artifact_to_revision_id_none():
     """Current loader version should stop soon if nothing can be found
 
     """
     artifact_metadata = {
         'digests': {
             'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec',  # noqa
         },
     }
 
     assert artifact_to_revision_id({}, artifact_metadata) is None
 
     known_artifacts = {
         'b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92': {
             'original_artifact': {
                 'sha256': 'something-irrelevant',
             },
         },
     }
 
     assert artifact_to_revision_id(known_artifacts, artifact_metadata) is None
 
 
 def test_pypi_artifact_to_revision_id_old_loader_version():
     """Current loader version should solve old metadata scheme
 
     """
     artifact_metadata = {
         'digests': {
             'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec',  # noqa
         }
     }
 
     known_artifacts = {
         hash_to_bytes('b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92'): {
             'original_artifact': {
                 'sha256': "something-wrong",
              },
         },
         hash_to_bytes('845673bfe8cbd31b1eaf757745a964137e6f9116'): {
             'original_artifact': {
                 'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec',  # noqa
              },
         }
     }
 
     assert artifact_to_revision_id(known_artifacts, artifact_metadata) \
         == hash_to_bytes('845673bfe8cbd31b1eaf757745a964137e6f9116')
 
 
 def test_pypi_artifact_to_revision_id_current_loader_version():
     """Current loader version should be able to solve current metadata scheme
 
     """
     artifact_metadata = {
         'digests': {
             'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec', # noqa
         }
     }
 
     known_artifacts = {
         hash_to_bytes('b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92'): {
             'original_artifact': [{
                 'checksums': {
                     'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec',  # noqa
                 },
             }],
         },
         hash_to_bytes('845673bfe8cbd31b1eaf757745a964137e6f9116'): {
             'original_artifact': [{
                 'checksums': {
                     'sha256': 'something-wrong'
                 },
             }],
         },
     }
 
     assert artifact_to_revision_id(known_artifacts, artifact_metadata) \
         == hash_to_bytes('b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92')
 
 
 def test_pypi_artifact_to_revision_id_failures():
     with pytest.raises(KeyError, match='sha256'):
         artifact_metadata = {
             'digests': {},
         }
         assert artifact_to_revision_id({}, artifact_metadata)
 
     with pytest.raises(KeyError, match='digests'):
         artifact_metadata = {
             'something': 'wrong',
         }
         assert artifact_to_revision_id({}, artifact_metadata)
 
 
 def test_pypi_artifact_with_no_intrinsic_metadata(
         swh_config, requests_mock_datadir):
     """Skip artifact with no intrinsic metadata during ingestion
 
     """
     url = 'https://pypi.org/project/upymenu'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = '1a8893e6a86f444e8be8e7bda6cb34fb1735a00e'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id,
     }
 
     # no branch as one artifact without any intrinsic metadata
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': {}
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'