diff --git a/swh/loader/exception.py b/swh/loader/exception.py
new file mode 100644
index 0000000..fd28021
--- /dev/null
+++ b/swh/loader/exception.py
@@ -0,0 +1,13 @@
+# Copyright (C) 2021  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
+
+
+class NotFound(ValueError):
+    """An exception raised when some information to retrieve is not found (e.g origin,
+       artifact, ...)
+
+    """
+
+    pass
diff --git a/swh/loader/package/loader.py b/swh/loader/package/loader.py
index b81e1bd..bb93a3b 100644
--- a/swh/loader/package/loader.py
+++ b/swh/loader/package/loader.py
@@ -1,803 +1,819 @@
 # Copyright (C) 2019-2021  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
 from itertools import islice
 import json
 import logging
 import os
 import sys
 import tempfile
 from typing import (
     Any,
     Dict,
     Generic,
     Iterable,
     Iterator,
     List,
     Mapping,
     Optional,
     Sequence,
     Tuple,
     TypeVar,
 )
 
 import attr
 import sentry_sdk
 
 from swh.core.config import load_from_envvar
 from swh.core.tarball import uncompress
+from swh.loader.exception import NotFound
 from swh.loader.package.utils import download
 from swh.model import from_disk
 from swh.model.collections import ImmutableDict
 from swh.model.hashutil import hash_to_hex
 from swh.model.identifiers import SWHID
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     MetadataFetcher,
     MetadataTargetType,
     Origin,
     OriginVisit,
     OriginVisitStatus,
     RawExtrinsicMetadata,
     Revision,
     Sha1Git,
     Snapshot,
     TargetType,
 )
 from swh.storage import get_storage
 from swh.storage.algos.snapshot import snapshot_get_latest
 from swh.storage.interface import StorageInterface
 from swh.storage.utils import now
 
 logger = logging.getLogger(__name__)
 
 
 SWH_METADATA_AUTHORITY = MetadataAuthority(
     type=MetadataAuthorityType.REGISTRY,
     url="https://softwareheritage.org/",
     metadata={},
 )
 """Metadata authority for extrinsic metadata generated by Software Heritage.
 Used for metadata on "original artifacts", ie. length, filename, and checksums
 of downloaded archive files."""
 
 
 @attr.s
 class RawExtrinsicMetadataCore:
     """Contains the core of the metadata extracted by a loader, that will be
     used to build a full RawExtrinsicMetadata object by adding object identifier,
     context, and provenance information."""
 
     format = attr.ib(type=str)
     metadata = attr.ib(type=bytes)
     discovery_date = attr.ib(type=Optional[datetime.datetime], default=None)
     """Defaults to the visit date."""
 
 
 @attr.s
 class BasePackageInfo:
     """Compute the primary key for a dict using the id_keys as primary key
        composite.
 
     Args:
         d: A dict entry to compute the primary key on
         id_keys: Sequence of keys to use as primary key
 
     Returns:
         The identity for that dict entry
 
     """
 
     url = attr.ib(type=str)
     filename = attr.ib(type=Optional[str])
 
     # The following attribute has kw_only=True in order to allow subclasses
     # to add attributes. Without kw_only, attributes without default values cannot
     # go after attributes with default values.
     # See <https://github.com/python-attrs/attrs/issues/38>
 
     directory_extrinsic_metadata = attr.ib(
         type=List[RawExtrinsicMetadataCore], default=[], kw_only=True,
     )
 
     # TODO: add support for metadata for directories and contents
 
     @property
     def ID_KEYS(self):
         raise NotImplementedError(f"{self.__class__.__name__} is missing ID_KEYS")
 
     def artifact_identity(self):
         return [getattr(self, k) for k in self.ID_KEYS]
 
 
 TPackageInfo = TypeVar("TPackageInfo", bound=BasePackageInfo)
 
 
 DEFAULT_CONFIG = {
     "max_content_size": 100 * 1024 * 1024,
     "create_authorities": True,
     "create_fetchers": True,
 }
 
 
 class PackageLoader(Generic[TPackageInfo]):
     # 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 = load_from_envvar(DEFAULT_CONFIG)
         self._check_configuration()
         self.storage: StorageInterface = 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.
 
+        Raises:
+           `class:swh.loader.exception.NotFound` error when failing to read the
+            published package versions.
+
         Returns:
             Sequence of published versions
 
         """
         return []
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, TPackageInfo]]:
         """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, p_info: TPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Revision]:
         """Build the revision from the archive metadata (extrinsic
         artifact metadata) and the intrinsic metadata.
 
         Args:
             p_info: Package information
             uncompressed_path: Artifact uncompressed path on disk
 
         Returns:
             Revision object
 
         """
         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 out of the last visit.
 
         """
         return snapshot_get_latest(self.storage, self.url)
 
     def known_artifacts(
         self, snapshot: Optional[Snapshot]
     ) -> Dict[Sha1Git, Optional[ImmutableDict[str, object]]]:
         """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)
         return {
             revision.id: revision.metadata for revision in known_revisions if revision
         }
 
     def resolve_revision_from(
         self, known_artifacts: Dict, p_info: TPackageInfo,
     ) -> 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
             p_info: Package information
 
         Returns:
             None or revision identifier
 
         """
         return None
 
     def download_package(
         self, p_info: TPackageInfo, 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)
 
         """
         return [download(p_info.url, dest=tmpdir, filename=p_info.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"  # see swh.model.model.OriginVisitStatus
         tmp_revisions = {}  # type: Dict[str, List]
         snapshot = None
         failed_branches: List[str] = []
 
         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
 
             """
             self.storage.flush()
 
             snapshot_id: Optional[bytes] = None
             if snapshot and snapshot.id:  # to prevent the snapshot.id to b""
                 snapshot_id = snapshot.id
             assert visit.visit
             visit_status = OriginVisitStatus(
                 origin=self.url,
                 visit=visit.visit,
                 type=self.visit_type,
                 date=now(),
                 status=status_visit,
                 snapshot=snapshot_id,
             )
             self.storage.origin_visit_status_add([visit_status])
             result: Dict[str, Any] = {
                 "status": status_load,
             }
             if snapshot_id:
                 result["snapshot_id"] = hash_to_hex(snapshot_id)
             if failed_branches:
                 logger.warning("%d failed branches", len(failed_branches))
                 for i, urls in enumerate(islice(failed_branches, 50)):
                     prefix_url = "Failed branches: " if i == 0 else ""
                     logger.warning("%s%s", prefix_url, urls)
 
             return result
 
         # Prepare origin and origin_visit
         origin = Origin(url=self.url)
         try:
             self.storage.origin_add([origin])
             visit = list(
                 self.storage.origin_visit_add(
                     [
                         OriginVisit(
                             origin=self.url, date=self.visit_date, type=self.visit_type,
                         )
                     ]
                 )
             )[0]
         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 = "failed"
             status_load = "failed"
             return finalize_visit()
 
         load_exceptions: List[Exception] = []
 
-        for version in self.get_versions():  # for each
+        try:
+            versions = self.get_versions()
+        except NotFound:
+            status_visit = "not_found"
+            status_load = "failed"
+            return finalize_visit()
+        except Exception:
+            status_visit = "failed"
+            status_load = "failed"
+            return finalize_visit()
+
+        for version in versions:
             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)
                 if revision_id is None:
                     try:
                         res = self._load_revision(p_info, origin)
                         if res:
                             (revision_id, directory_id) = res
                             assert revision_id
                             assert directory_id
                             self._load_extrinsic_directory_metadata(
                                 p_info, revision_id, directory_id
                             )
                         self.storage.flush()
                         status_load = "eventful"
                     except Exception as e:
                         self.storage.clear_buffers()
                         load_exceptions.append(e)
                         sentry_sdk.capture_exception(e)
                         logger.exception(
                             "Failed loading branch %s for %s", branch_name, self.url
                         )
                         failed_branches.append(branch_name)
                         continue
 
                     if revision_id is None:
                         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"
             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
             )
             self.storage.flush()
         except Exception as e:
             logger.exception("Failed to build snapshot for origin %s", self.url)
             sentry_sdk.capture_exception(e)
             status_visit = "failed"
             status_load = "failed"
 
         if snapshot:
             try:
                 metadata_objects = self.build_extrinsic_snapshot_metadata(snapshot.id)
                 self._load_metadata_objects(metadata_objects)
             except Exception as e:
                 logger.exception(
                     "Failed to load extrinsic snapshot metadata for %s", self.url
                 )
                 sentry_sdk.capture_exception(e)
                 status_visit = "partial"
                 status_load = "failed"
 
         try:
             metadata_objects = self.build_extrinsic_origin_metadata()
             self._load_metadata_objects(metadata_objects)
         except Exception as e:
             logger.exception(
                 "Failed to load extrinsic origin metadata for %s", self.url
             )
             sentry_sdk.capture_exception(e)
             status_visit = "partial"
             status_load = "failed"
 
         return finalize_visit()
 
     def _load_directory(
         self, dl_artifacts: List[Tuple[str, Mapping[str, Any]]], tmpdir: str
     ) -> Tuple[str, from_disk.Directory]:
         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, skipped_contents, directories = from_disk.iter_directory(directory)
 
         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)
 
         return (uncompressed_path, directory)
 
     def _load_revision(
         self, p_info: TPackageInfo, origin
     ) -> Optional[Tuple[Sha1Git, 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, directory_id)
 
         Raises
             exception when unable to download or uncompress artifacts
 
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             dl_artifacts = self.download_package(p_info, tmpdir)
 
             (uncompressed_path, directory) = self._load_directory(dl_artifacts, tmpdir)
 
             # FIXME: This should be release. cf. D409
             revision = self.build_revision(
                 p_info, uncompressed_path, directory=directory.hash
             )
             if not revision:
                 # Some artifacts are missing intrinsic metadata
                 # skipping those
                 return None
 
         metadata = [metadata for (filepath, metadata) in dl_artifacts]
         extra_metadata: Tuple[str, Any] = (
             "original_artifact",
             metadata,
         )
 
         if revision.metadata is not None:
             full_metadata = list(revision.metadata.items()) + [extra_metadata]
         else:
             full_metadata = [extra_metadata]
 
         # TODO: don't add these extrinsic metadata to the revision.
         revision = attr.evolve(revision, metadata=ImmutableDict(full_metadata))
 
         original_artifact_metadata = RawExtrinsicMetadata(
             type=MetadataTargetType.DIRECTORY,
             target=SWHID(object_type="directory", object_id=revision.directory),
             discovery_date=self.visit_date,
             authority=SWH_METADATA_AUTHORITY,
             fetcher=self.get_metadata_fetcher(),
             format="original-artifacts-json",
             metadata=json.dumps(metadata).encode(),
             origin=self.url,
             revision=SWHID(object_type="revision", object_id=revision.id),
         )
         self._load_metadata_objects([original_artifact_metadata])
 
         logger.debug("Revision: %s", revision)
 
         self.storage.revision_add([revision])
         assert directory.hash
         return (revision.id, directory.hash)
 
     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
 
     def get_loader_name(self) -> str:
         """Returns a fully qualified name of this loader."""
         return f"{self.__class__.__module__}.{self.__class__.__name__}"
 
     def get_loader_version(self) -> str:
         """Returns the version of the current loader."""
         module_name = self.__class__.__module__ or ""
         module_name_parts = module_name.split(".")
 
         # Iterate rootward through the package hierarchy until we find a parent of this
         # loader's module with a __version__ attribute.
         for prefix_size in range(len(module_name_parts), 0, -1):
             package_name = ".".join(module_name_parts[0:prefix_size])
             module = sys.modules[package_name]
             if hasattr(module, "__version__"):
                 return module.__version__  # type: ignore
 
         # If this loader's class has no parent package with a __version__,
         # it should implement it itself.
         raise NotImplementedError(
             f"Could not dynamically find the version of {self.get_loader_name()}."
         )
 
     def get_metadata_fetcher(self) -> MetadataFetcher:
         """Returns a MetadataFetcher instance representing this package loader;
         which is used to for adding provenance information to extracted
         extrinsic metadata, if any."""
         return MetadataFetcher(
             name=self.get_loader_name(), version=self.get_loader_version(), metadata={},
         )
 
     def get_metadata_authority(self) -> MetadataAuthority:
         """For package loaders that get extrinsic metadata, returns the authority
         the metadata are coming from.
         """
         raise NotImplementedError("get_metadata_authority")
 
     def get_extrinsic_origin_metadata(self) -> List[RawExtrinsicMetadataCore]:
         """Returns metadata items, used by build_extrinsic_origin_metadata."""
         return []
 
     def build_extrinsic_origin_metadata(self) -> List[RawExtrinsicMetadata]:
         """Builds a list of full RawExtrinsicMetadata objects, using
         metadata returned by get_extrinsic_origin_metadata."""
         metadata_items = self.get_extrinsic_origin_metadata()
         if not metadata_items:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return []
 
         authority = self.get_metadata_authority()
         fetcher = self.get_metadata_fetcher()
 
         metadata_objects = []
 
         for item in metadata_items:
             metadata_objects.append(
                 RawExtrinsicMetadata(
                     type=MetadataTargetType.ORIGIN,
                     target=self.url,
                     discovery_date=item.discovery_date or self.visit_date,
                     authority=authority,
                     fetcher=fetcher,
                     format=item.format,
                     metadata=item.metadata,
                 )
             )
 
         return metadata_objects
 
     def get_extrinsic_snapshot_metadata(self) -> List[RawExtrinsicMetadataCore]:
         """Returns metadata items, used by build_extrinsic_snapshot_metadata."""
         return []
 
     def build_extrinsic_snapshot_metadata(
         self, snapshot_id: Sha1Git
     ) -> List[RawExtrinsicMetadata]:
         """Builds a list of full RawExtrinsicMetadata objects, using
         metadata returned by get_extrinsic_snapshot_metadata."""
         metadata_items = self.get_extrinsic_snapshot_metadata()
         if not metadata_items:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return []
 
         authority = self.get_metadata_authority()
         fetcher = self.get_metadata_fetcher()
 
         metadata_objects = []
 
         for item in metadata_items:
             metadata_objects.append(
                 RawExtrinsicMetadata(
                     type=MetadataTargetType.SNAPSHOT,
                     target=SWHID(object_type="snapshot", object_id=snapshot_id),
                     discovery_date=item.discovery_date or self.visit_date,
                     authority=authority,
                     fetcher=fetcher,
                     format=item.format,
                     metadata=item.metadata,
                     origin=self.url,
                 )
             )
 
         return metadata_objects
 
     def build_extrinsic_directory_metadata(
         self, p_info: TPackageInfo, revision_id: Sha1Git, directory_id: Sha1Git,
     ) -> List[RawExtrinsicMetadata]:
         if not p_info.directory_extrinsic_metadata:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return []
 
         authority = self.get_metadata_authority()
         fetcher = self.get_metadata_fetcher()
 
         metadata_objects = []
 
         for item in p_info.directory_extrinsic_metadata:
             metadata_objects.append(
                 RawExtrinsicMetadata(
                     type=MetadataTargetType.DIRECTORY,
                     target=SWHID(object_type="directory", object_id=directory_id),
                     discovery_date=item.discovery_date or self.visit_date,
                     authority=authority,
                     fetcher=fetcher,
                     format=item.format,
                     metadata=item.metadata,
                     origin=self.url,
                     revision=SWHID(
                         object_type="revision", object_id=hash_to_hex(revision_id)
                     ),
                 )
             )
 
         return metadata_objects
 
     def _load_extrinsic_directory_metadata(
         self, p_info: TPackageInfo, revision_id: Sha1Git, directory_id: Sha1Git,
     ) -> None:
         metadata_objects = self.build_extrinsic_directory_metadata(
             p_info, revision_id, directory_id
         )
         self._load_metadata_objects(metadata_objects)
 
     def _load_metadata_objects(
         self, metadata_objects: List[RawExtrinsicMetadata]
     ) -> None:
         if not metadata_objects:
             # If this package loader doesn't write metadata, no need to require
             # an implementation for get_metadata_authority.
             return
 
         self._create_authorities(mo.authority for mo in metadata_objects)
         self._create_fetchers(mo.fetcher for mo in metadata_objects)
 
         self.storage.raw_extrinsic_metadata_add(metadata_objects)
 
     def _create_authorities(self, authorities: Iterable[MetadataAuthority]) -> None:
         deduplicated_authorities = {
             (authority.type, authority.url): authority for authority in authorities
         }
         if authorities:
             self.storage.metadata_authority_add(list(deduplicated_authorities.values()))
 
     def _create_fetchers(self, fetchers: Iterable[MetadataFetcher]) -> None:
         deduplicated_fetchers = {
             (fetcher.name, fetcher.version): fetcher for fetcher in fetchers
         }
         if fetchers:
             self.storage.metadata_fetcher_add(list(deduplicated_fetchers.values()))
diff --git a/swh/loader/package/nixguix/loader.py b/swh/loader/package/nixguix/loader.py
index b936054..b09e63d 100644
--- a/swh/loader/package/nixguix/loader.py
+++ b/swh/loader/package/nixguix/loader.py
@@ -1,320 +1,327 @@
-# Copyright (C) 2020  The Software Heritage developers
+# Copyright (C) 2020-2021  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 copy
 import json
 import logging
 import re
 from typing import Any, Dict, Iterator, List, Mapping, Optional, Tuple
 
 import attr
 
 from swh.loader.package.loader import (
     BasePackageInfo,
     PackageLoader,
     RawExtrinsicMetadataCore,
 )
-from swh.loader.package.utils import EMPTY_AUTHOR, api_info
+from swh.loader.package.utils import EMPTY_AUTHOR, api_info, cached_method
 from swh.model import hashutil
 from swh.model.collections import ImmutableDict
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     Revision,
     RevisionType,
     Sha1Git,
     Snapshot,
     TargetType,
 )
 
 logger = logging.getLogger(__name__)
 
 
 @attr.s
 class NixGuixPackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
 
     integrity = attr.ib(type=str)
     """Hash of the archive, formatted as in the Subresource Integrity
     specification."""
 
     @classmethod
     def from_metadata(cls, metadata: Dict[str, Any]) -> "NixGuixPackageInfo":
         return cls(
             url=metadata["url"],
             filename=None,
             integrity=metadata["integrity"],
             raw_info=metadata,
         )
 
 
 class NixGuixLoader(PackageLoader[NixGuixPackageInfo]):
     """Load sources from a sources.json file. This loader is used to load
     sources used by functional package manager (eg. Nix and Guix).
 
     """
 
     visit_type = "nixguix"
 
     def __init__(self, url):
         super().__init__(url=url)
-        unsupported_file_extensions = self.config.get("unsupported_file_extensions", [])
-        self.raw_sources = retrieve_sources(url)
-        clean = clean_sources(
-            parse_sources(self.raw_sources), unsupported_file_extensions
-        )
-        self.sources = clean["sources"]
         self.provider_url = url
 
-        self._integrityByUrl = {s["urls"][0]: s["integrity"] for s in self.sources}
-
-        # The revision used to create the sources.json file. For Nix,
-        # this revision belongs to the github.com/nixos/nixpkgs
-        # repository
-        self.revision = clean["revision"]
-
     # Note: this could be renamed get_artifacts in the PackageLoader
     # base class.
-    def get_versions(self):
+    @cached_method
+    def raw_sources(self):
+        return retrieve_sources(self.url)
+
+    @cached_method
+    def supported_sources(self):
+        raw_sources = self.raw_sources()
+        unsupported_file_extensions = self.config.get("unsupported_file_extensions", [])
+        return clean_sources(parse_sources(raw_sources), unsupported_file_extensions)
+
+    @cached_method
+    def integrity_by_url(self) -> Dict[str, Any]:
+        sources = self.supported_sources()
+        return {s["urls"][0]: s["integrity"] for s in sources["sources"]}
+
+    def get_versions(self) -> List[str]:
         """The first mirror of the mirror list is used as branch name in the
         snapshot.
 
         """
-        return self._integrityByUrl.keys()
+        return list(self.integrity_by_url().keys())
 
     def get_metadata_authority(self):
         return MetadataAuthority(
             type=MetadataAuthorityType.FORGE, url=self.url, metadata={},
         )
 
     def get_extrinsic_snapshot_metadata(self):
         return [
             RawExtrinsicMetadataCore(
-                format="nixguix-sources-json", metadata=self.raw_sources,
+                format="nixguix-sources-json", metadata=self.raw_sources(),
             ),
         ]
 
     # Note: this could be renamed get_artifact_info in the PackageLoader
     # base class.
     def get_package_info(self, url) -> Iterator[Tuple[str, NixGuixPackageInfo]]:
         # TODO: try all mirrors and not only the first one. A source
         # can be fetched from several urls, called mirrors. We
         # currently only use the first one, but if the first one
         # fails, we should try the second one and so on.
-        integrity = self._integrityByUrl[url]
+        integrity = self.integrity_by_url()[url]
         p_info = NixGuixPackageInfo.from_metadata({"url": url, "integrity": integrity})
         yield url, p_info
 
     def known_artifacts(
         self, snapshot: Optional[Snapshot]
     ) -> Dict[Sha1Git, Optional[ImmutableDict[str, object]]]:
         """Almost same implementation as the default one except it filters out the extra
         "evaluation" branch which does not have the right metadata structure.
 
         """
         if not snapshot:
             return {}
 
         # Skip evaluation revision which has no metadata
         revs = [
             rev.target
             for branch_name, rev in snapshot.branches.items()
             if (
                 rev
                 and rev.target_type == TargetType.REVISION
                 and branch_name != b"evaluation"
             )
         ]
         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, p_info: NixGuixPackageInfo,
     ) -> Optional[bytes]:
         for rev_id, known_artifact in known_artifacts.items():
             try:
                 known_integrity = known_artifact["extrinsic"]["raw"]["integrity"]
             except KeyError as e:
                 logger.exception(
                     "Unexpected metadata revision structure detected: %(context)s",
                     {
                         "context": {
                             "revision": hashutil.hash_to_hex(rev_id),
                             "reason": str(e),
                             "known_artifact": known_artifact,
                         }
                     },
                 )
                 # metadata field for the revision is not as expected by the loader
                 # nixguix. We consider this not the right revision and continue checking
                 # the other revisions
                 continue
             else:
                 if p_info.integrity == known_integrity:
                     return rev_id
         return None
 
     def extra_branches(self) -> Dict[bytes, Mapping[str, Any]]:
         """We add a branch to the snapshot called 'evaluation' pointing to the
         revision used to generate the sources.json file. This revision
         is specified in the sources.json file itself. For the nixpkgs
         origin, this revision is coming from the
         github.com/nixos/nixpkgs repository.
 
         Note this repository is not loaded explicitly. So, this
         pointer can target a nonexistent revision for a time. However,
         the github and gnu loaders are supposed to load this revision
         and should create the revision pointed by this branch.
 
         This branch can be used to identify the snapshot associated to
         a Nix/Guix evaluation.
 
         """
+        # The revision used to create the sources.json file. For Nix,
+        # this revision belongs to the github.com/nixos/nixpkgs
+        # repository
+        revision = self.supported_sources()["revision"]
         return {
             b"evaluation": {
                 "target_type": "revision",
-                "target": hashutil.hash_to_bytes(self.revision),
+                "target": hashutil.hash_to_bytes(revision),
             }
         }
 
     def build_revision(
         self, p_info: NixGuixPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Revision]:
         return Revision(
             type=RevisionType.TAR,
             message=b"",
             author=EMPTY_AUTHOR,
             date=None,
             committer=EMPTY_AUTHOR,
             committer_date=None,
             parents=(),
             directory=directory,
             synthetic=True,
             metadata={
                 "extrinsic": {
                     "provider": self.provider_url,
                     "when": self.visit_date.isoformat(),
                     "raw": p_info.raw_info,
                 },
             },
         )
 
 
 def retrieve_sources(url: str) -> bytes:
+    """Retrieve sources. Potentially raise NotFound error."""
     return api_info(url, allow_redirects=True)
 
 
 def parse_sources(raw_sources: bytes) -> Dict[str, Any]:
     return json.loads(raw_sources.decode("utf-8"))
 
 
 def make_pattern_unsupported_file_extension(unsupported_file_extensions: List[str],):
     """Make a regexp pattern for unsupported file extension out of a list
     of unsupported archive extension list.
 
     """
     return re.compile(
         rf".*\.({'|'.join(map(re.escape, unsupported_file_extensions))})$", re.DOTALL
     )
 
 
 def clean_sources(
     sources: Dict[str, Any], unsupported_file_extensions=[]
 ) -> Dict[str, Any]:
     """Validate and clean the sources structure. First, ensure all top level keys are
     present. Then, walk the sources list and remove sources that do not contain required
     keys.
 
     Filter out source entries whose:
     - required keys are missing
     - source type is not supported
     - urls attribute type is not a list
     - extension is known not to be supported by the loader
 
     Raises:
         ValueError if:
         - a required top level key is missing
         - top-level version is not 1
 
     Returns:
         source Dict cleaned up
 
     """
     pattern_unsupported_file = make_pattern_unsupported_file_extension(
         unsupported_file_extensions
     )
     # Required top level keys
     required_keys = ["version", "revision", "sources"]
     missing_keys = []
     for required_key in required_keys:
         if required_key not in sources:
             missing_keys.append(required_key)
 
     if missing_keys != []:
         raise ValueError(
             f"sources structure invalid, missing: {','.join(missing_keys)}"
         )
 
     # Only the version 1 is currently supported
     version = int(sources["version"])
     if version != 1:
         raise ValueError(
             f"The sources structure version '{sources['version']}' is not supported"
         )
 
     # If a source doesn't contain required attributes, this source is
     # skipped but others could still be archived.
     verified_sources = []
     for source in sources["sources"]:
         valid = True
         required_keys = ["urls", "integrity", "type"]
         for required_key in required_keys:
             if required_key not in source:
                 logger.info(
                     f"Skip source '{source}' because key '{required_key}' is missing",
                 )
                 valid = False
 
         if valid and source["type"] != "url":
             logger.info(
                 f"Skip source '{source}' because the type {source['type']} "
                 "is not supported",
             )
             valid = False
 
         if valid and not isinstance(source["urls"], list):
             logger.info(
                 f"Skip source {source} because the urls attribute is not a list"
             )
             valid = False
 
         if valid and len(source["urls"]) > 0:  # Filter out unsupported archives
             supported_sources: List[str] = []
             for source_url in source["urls"]:
                 if pattern_unsupported_file.match(source_url):
                     logger.info(f"Skip unsupported artifact url {source_url}")
                     continue
                 supported_sources.append(source_url)
 
             if len(supported_sources) == 0:
                 logger.info(
                     f"Skip source {source} because urls only reference "
                     "unsupported artifacts. Unsupported "
                     f"artifacts so far: {pattern_unsupported_file}"
                 )
                 continue
 
             new_source = copy.deepcopy(source)
             new_source["urls"] = supported_sources
             verified_sources.append(new_source)
 
     sources["sources"] = verified_sources
     return sources
diff --git a/swh/loader/package/nixguix/tests/test_nixguix.py b/swh/loader/package/nixguix/tests/test_nixguix.py
index 06d61d5..d1d108f 100644
--- a/swh/loader/package/nixguix/tests/test_nixguix.py
+++ b/swh/loader/package/nixguix/tests/test_nixguix.py
@@ -1,672 +1,691 @@
-# Copyright (C) 2020 The Software Heritage developers
+# Copyright (C) 2020-2021 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
-from json.decoder import JSONDecodeError
 import logging
 import os
 from typing import Dict, Optional, Tuple
 from unittest.mock import patch
 
 import attr
 import pytest
 
 from swh.loader.package import __version__
 from swh.loader.package.archive.loader import ArchiveLoader
 from swh.loader.package.nixguix.loader import (
     NixGuixLoader,
     NixGuixPackageInfo,
     clean_sources,
     make_pattern_unsupported_file_extension,
     parse_sources,
     retrieve_sources,
 )
 from swh.loader.package.utils import download
 from swh.loader.tests import assert_last_visit_matches
 from swh.loader.tests import check_snapshot as check_snapshot_full
 from swh.loader.tests import get_stats
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.identifiers import SWHID
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     MetadataFetcher,
     MetadataTargetType,
     RawExtrinsicMetadata,
     Snapshot,
     SnapshotBranch,
     TargetType,
 )
 from swh.storage.algos.origin import origin_get_latest_visit_status
 from swh.storage.algos.snapshot import snapshot_get_all_branches
 from swh.storage.exc import HashCollision
 from swh.storage.interface import PagedResult, StorageInterface
 
 sources_url = "https://nix-community.github.io/nixpkgs-swh/sources.json"
 
 
 @pytest.fixture
 def raw_sources(datadir) -> bytes:
     with open(
         os.path.join(
             datadir, "https_nix-community.github.io", "nixpkgs-swh_sources.json"
         ),
         "rb",
     ) as f:
         return f.read()
 
 
 SNAPSHOT1 = Snapshot(
     id=hash_to_bytes("0c5881c74283793ebe9a09a105a9381e41380383"),
     branches={
         b"evaluation": SnapshotBranch(
             target=hash_to_bytes("cc4e04c26672dd74e5fd0fecb78b435fb55368f7"),
             target_type=TargetType.REVISION,
         ),
         b"https://github.com/owner-1/repository-1/revision-1.tgz": SnapshotBranch(
             target=hash_to_bytes("488ad4e7b8e2511258725063cf43a2b897c503b4"),
             target_type=TargetType.REVISION,
         ),
     },
 )
 
 
 def check_snapshot(snapshot: Snapshot, storage: StorageInterface):
     # The `evaluation` branch is allowed to be unresolvable. It's possible at current
     # nixguix visit time, it is not yet visited (the git loader is in charge of its
     # visit for now). For more details, check the
     # swh.loader.package.nixguix.NixGuixLoader.extra_branches docstring.
     check_snapshot_full(
         snapshot, storage, allowed_empty=[(TargetType.REVISION, b"evaluation")]
     )
 
     assert isinstance(snapshot, Snapshot)
     # then ensure the snapshot revisions are structurally as expected
     revision_ids = []
     for name, branch in snapshot.branches.items():
         if name == b"evaluation":
             continue  # skipping that particular branch (cf. previous comment)
         if branch.target_type == TargetType.REVISION:
             revision_ids.append(branch.target)
 
     revisions = storage.revision_get(revision_ids)
     for rev in revisions:
         assert rev is not None
         metadata = rev.metadata
         assert metadata is not None
         raw = metadata["extrinsic"]["raw"]
         assert "url" in raw
         assert "integrity" in raw
 
 
 def test_retrieve_sources(swh_config, requests_mock_datadir):
     j = parse_sources(retrieve_sources(sources_url))
     assert "sources" in j.keys()
     assert len(j["sources"]) == 2
 
 
-def test_retrieve_non_existing(swh_config, requests_mock_datadir):
-    with pytest.raises(ValueError):
-        NixGuixLoader("https://non-existing-url")
+def test_nixguix_url_not_found(swh_config, requests_mock_datadir):
+    """When failing to read from the url, the visit is marked as not_found.
+
+    """
+    unknown_url = "https://non-existing-url"
+    loader = NixGuixLoader(unknown_url)
+    # during the retrieval step
+    load_status = loader.load()
+
+    assert load_status == {"status": "failed"}
+
+    assert_last_visit_matches(
+        loader.storage, unknown_url, status="not_found", type="nixguix", snapshot=None
+    )
 
 
-def test_retrieve_non_json(swh_config, requests_mock_datadir):
-    with pytest.raises(JSONDecodeError):
-        NixGuixLoader("https://example.com/file.txt")
+def test_nixguix_url_with_decoding_error(swh_config, requests_mock_datadir):
+    """Other errors during communication with the url, the visit is marked as failed"""
+    sources_url = "https://example.com/file.txt"
+    loader = NixGuixLoader(sources_url)
+    load_status = loader.load()
+
+    assert load_status == {"status": "failed"}
+
+    assert_last_visit_matches(
+        loader.storage, sources_url, status="failed", type="nixguix", snapshot=None
+    )
 
 
 def test_clean_sources_invalid_schema(swh_config, requests_mock_datadir):
     sources = {}
     with pytest.raises(ValueError, match="sources structure invalid, missing: .*"):
         clean_sources(sources)
 
 
 def test_clean_sources_invalid_version(swh_config, requests_mock_datadir):
     for version_ok in [1, "1"]:  # Check those versions are fine
         clean_sources({"version": version_ok, "sources": [], "revision": "my-revision"})
 
     for version_ko in [0, "0", 2, "2"]:  # Check version != 1 raise an error
         with pytest.raises(
             ValueError, match="sources structure version .* is not supported"
         ):
             clean_sources(
                 {"version": version_ko, "sources": [], "revision": "my-revision"}
             )
 
 
 def test_clean_sources_invalid_sources(swh_config, requests_mock_datadir):
     valid_sources = [
         # 1 valid source
         {"type": "url", "urls": ["my-url.tar.gz"], "integrity": "my-integrity"},
     ]
     sources = {
         "version": 1,
         "sources": valid_sources
         + [
             # integrity is missing
             {"type": "url", "urls": ["my-url.tgz"],},
             # urls is not a list
             {"type": "url", "urls": "my-url.zip", "integrity": "my-integrity"},
             # type is not url
             {"type": "git", "urls": ["my-url.zip"], "integrity": "my-integrity"},
             # missing fields which got double-checked nonetheless...
             {"integrity": "my-integrity"},
         ],
         "revision": "my-revision",
     }
     clean = clean_sources(sources)
 
     assert len(clean["sources"]) == len(valid_sources)
 
 
 def test_make_pattern_unsupported_file_extension():
     unsupported_extensions = ["el", "c", "txt"]
     supported_extensions = ["Z", "7z"]  # for test
 
     actual_unsupported_pattern = make_pattern_unsupported_file_extension(
         unsupported_extensions
     )
 
     for supported_ext in supported_extensions:
         assert supported_ext not in unsupported_extensions
 
         supported_filepath = f"anything.{supported_ext}"
         actual_match = actual_unsupported_pattern.match(supported_filepath)
         assert not actual_match
 
     for unsupported_ext in unsupported_extensions:
         unsupported_filepath = f"something.{unsupported_ext}"
         actual_match = actual_unsupported_pattern.match(unsupported_filepath)
         assert actual_match
 
 
 def test_clean_sources_unsupported_artifacts(swh_config, requests_mock_datadir):
     unsupported_file_extensions = [
         "iso",
         "whl",
         "gem",
         "pom",
         "msi",
         "pod",
         "png",
         "rock",
         "ttf",
         "jar",
         "c",
         "el",
         "rpm",
         "diff",
         "patch",
     ]
     supported_sources = [
         {
             "type": "url",
             "urls": [f"https://server.org/my-url.{ext}"],
             "integrity": "my-integrity",
         }
         for ext in [
             "known-unknown-but-ok",  # this is fine as well with the current approach
             "zip",
             "tar.gz",
             "tgz",
             "tar.bz2",
             "tbz",
             "tbz2",
             "tar.xz",
             "tar",
             "zip",
             "7z",
             "Z",
         ]
     ]
 
     unsupported_sources = [
         {
             "type": "url",
             "urls": [f"https://server.org/my-url.{ext}"],
             "integrity": "my-integrity",
         }
         for ext in unsupported_file_extensions
     ]
 
     sources = {
         "version": 1,
         "sources": supported_sources + unsupported_sources,
         "revision": "my-revision",
     }
 
     clean = clean_sources(sources, unsupported_file_extensions)
 
     assert len(clean["sources"]) == len(supported_sources)
 
 
 def test_loader_one_visit(swh_config, requests_mock_datadir, raw_sources):
     loader = NixGuixLoader(sources_url)
     res = loader.load()
     assert res["status"] == "eventful"
 
     stats = get_stats(loader.storage)
     assert {
         "content": 1,
         "directory": 3,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 1,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     # The visit is partial because urls pointing to non tarball file
     # are not handled yet
     assert_last_visit_matches(
         loader.storage, sources_url, status="partial", type="nixguix"
     )
 
     visit_status = origin_get_latest_visit_status(loader.storage, sources_url)
     snapshot_swhid = SWHID(
         object_type="snapshot", object_id=hash_to_hex(visit_status.snapshot)
     )
     metadata_authority = MetadataAuthority(
         type=MetadataAuthorityType.FORGE, url=sources_url,
     )
     expected_metadata = [
         RawExtrinsicMetadata(
             type=MetadataTargetType.SNAPSHOT,
             target=snapshot_swhid,
             authority=metadata_authority,
             fetcher=MetadataFetcher(
                 name="swh.loader.package.nixguix.loader.NixGuixLoader",
                 version=__version__,
             ),
             discovery_date=loader.visit_date,
             format="nixguix-sources-json",
             metadata=raw_sources,
             origin=sources_url,
         )
     ]
     assert loader.storage.raw_extrinsic_metadata_get(
         MetadataTargetType.SNAPSHOT, snapshot_swhid, metadata_authority,
     ) == PagedResult(next_page_token=None, results=expected_metadata,)
 
 
 def test_uncompress_failure(swh_config, requests_mock_datadir):
     """Non tarball files are currently not supported and the uncompress
     function fails on such kind of files.
 
     However, even in this case of failure (because of the url
     https://example.com/file.txt), a snapshot and a visit has to be
     created (with a status partial since all files are not archived).
 
     """
     loader = NixGuixLoader(sources_url)
     loader_status = loader.load()
 
-    urls = [s["urls"][0] for s in loader.sources]
+    sources = loader.supported_sources()["sources"]
+    urls = [s["urls"][0] for s in sources]
     assert "https://example.com/file.txt" in urls
     assert loader_status["status"] == "eventful"
 
     # The visit is partial because urls pointing to non tarball files
     # are not handled yet
     assert_last_visit_matches(
         loader.storage, sources_url, status="partial", type="nixguix"
     )
 
 
 def test_loader_incremental(swh_config, requests_mock_datadir):
     """Ensure a second visit do not download artifact already
     downloaded by the previous visit.
 
     """
     loader = NixGuixLoader(sources_url)
     load_status = loader.load()
 
     loader.load()
     assert load_status == {"status": "eventful", "snapshot_id": SNAPSHOT1.id.hex()}
 
     assert_last_visit_matches(
         loader.storage,
         sources_url,
         status="partial",
         type="nixguix",
         snapshot=SNAPSHOT1.id,
     )
 
     check_snapshot(SNAPSHOT1, storage=loader.storage)
 
     urls = [
         m.url
         for m in requests_mock_datadir.request_history
         if m.url == ("https://github.com/owner-1/repository-1/revision-1.tgz")
     ]
     # The artifact
     # 'https://github.com/owner-1/repository-1/revision-1.tgz' is only
     # visited one time
     assert len(urls) == 1
 
 
 def test_loader_two_visits(swh_config, requests_mock_datadir_visits):
     """To ensure there is only one origin, but two visits, two revisions
     and two snapshots are created.
 
     The first visit creates a snapshot containing one tarball. The
     second visit creates a snapshot containing the same tarball and
     another tarball.
 
     """
     loader = NixGuixLoader(sources_url)
     load_status = loader.load()
     assert load_status == {"status": "eventful", "snapshot_id": SNAPSHOT1.id.hex()}
 
     assert_last_visit_matches(
         loader.storage,
         sources_url,
         status="partial",
         type="nixguix",
         snapshot=SNAPSHOT1.id,
     )
 
     check_snapshot(SNAPSHOT1, storage=loader.storage)
 
     stats = get_stats(loader.storage)
     assert {
         "content": 1,
         "directory": 3,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 1,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     loader = NixGuixLoader(sources_url)
     load_status = loader.load()
     expected_snapshot_id_hex = "b0bfa75cbd0cc90aac3b9e95fb0f59c731176d97"
     expected_snapshot_id = hash_to_bytes(expected_snapshot_id_hex)
     assert load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id_hex,
     }
 
     assert_last_visit_matches(
         loader.storage,
         sources_url,
         status="partial",
         type="nixguix",
         snapshot=expected_snapshot_id,
     )
 
     # This ensures visits are incremental. Indeed, if we request a
     # second time an url, because of the requests_mock_datadir_visits
     # fixture, the file has to end with `_visit1`.
     expected_snapshot = Snapshot(
         id=expected_snapshot_id,
         branches={
             b"evaluation": SnapshotBranch(
                 target=hash_to_bytes("602140776b2ce6c9159bcf52ada73a297c063d5e"),
                 target_type=TargetType.REVISION,
             ),
             b"https://github.com/owner-1/repository-1/revision-1.tgz": SnapshotBranch(
                 target=hash_to_bytes("488ad4e7b8e2511258725063cf43a2b897c503b4"),
                 target_type=TargetType.REVISION,
             ),
             b"https://github.com/owner-2/repository-1/revision-1.tgz": SnapshotBranch(
                 target=hash_to_bytes("85e0bad74e33e390aaeb74f139853ae3863ee544"),
                 target_type=TargetType.REVISION,
             ),
         },
     )
     check_snapshot(expected_snapshot, storage=loader.storage)
 
     stats = get_stats(loader.storage)
     assert {
         "content": 2,
         "directory": 5,
         "origin": 1,
         "origin_visit": 2,
         "release": 0,
         "revision": 2,
         "skipped_content": 0,
         "snapshot": 2,
     } == stats
 
 
 def test_resolve_revision_from(swh_config, requests_mock_datadir, datadir):
     loader = NixGuixLoader(sources_url)
 
     known_artifacts = {
         "id1": {"extrinsic": {"raw": {"url": "url1", "integrity": "integrity1"}}},
         "id2": {"extrinsic": {"raw": {"url": "url2", "integrity": "integrity2"}}},
     }
 
     p_info = NixGuixPackageInfo.from_metadata(
         {"url": "url1", "integrity": "integrity1"}
     )
     assert loader.resolve_revision_from(known_artifacts, p_info) == "id1"
     p_info = NixGuixPackageInfo.from_metadata(
         {"url": "url3", "integrity": "integrity3"}
     )
     assert loader.resolve_revision_from(known_artifacts, p_info) == None  # noqa
 
 
 def test_evaluation_branch(swh_config, requests_mock_datadir):
     loader = NixGuixLoader(sources_url)
     res = loader.load()
     assert res["status"] == "eventful"
 
     assert_last_visit_matches(
         loader.storage,
         sources_url,
         status="partial",
         type="nixguix",
         snapshot=SNAPSHOT1.id,
     )
 
     check_snapshot(SNAPSHOT1, storage=loader.storage)
 
 
 def test_eoferror(swh_config, requests_mock_datadir):
     """Load a truncated archive which is invalid to make the uncompress
     function raising the exception EOFError. We then check if a
     snapshot is created, meaning this error is well managed.
 
     """
     sources = (
         "https://nix-community.github.io/nixpkgs-swh/sources-EOFError.json"  # noqa
     )
     loader = NixGuixLoader(sources)
     loader.load()
 
     expected_snapshot = Snapshot(
         id=hash_to_bytes("4257fa2350168c6bfec726a06452ea27a2c0cb33"),
         branches={
             b"evaluation": SnapshotBranch(
                 target=hash_to_bytes("cc4e04c26672dd74e5fd0fecb78b435fb55368f7"),
                 target_type=TargetType.REVISION,
             ),
         },
     )
 
     check_snapshot(expected_snapshot, storage=loader.storage)
 
 
 def fake_download(
     url: str,
     dest: str,
     hashes: Dict = {},
     filename: Optional[str] = None,
     auth: Optional[Tuple[str, str]] = None,
 ) -> Tuple[str, Dict]:
     """Fake download which raises HashCollision (for the sake of test simpliciy,
     let's accept that makes sense)
 
     For tests purpose only.
 
     """
     if url == "https://example.com/file.txt":
         # instead of failing because it's a file not dealt with by the nix guix
         # loader, make it raise a hash collision
         raise HashCollision("sha1", "f92d74e3874587aaf443d1db961d4e26dde13e9c", [])
     return download(url, dest, hashes, filename, auth)
 
 
 def test_raise_exception(swh_config, requests_mock_datadir, mocker):
     mock_download = mocker.patch("swh.loader.package.loader.download")
     mock_download.side_effect = fake_download
 
     loader = NixGuixLoader(sources_url)
     res = loader.load()
 
     assert res == {
         "status": "eventful",
         "snapshot_id": SNAPSHOT1.id.hex(),
     }
 
     check_snapshot(SNAPSHOT1, storage=loader.storage)
 
     assert len(mock_download.mock_calls) == 2
 
     # The visit is partial because some artifact downloads failed
     assert_last_visit_matches(
         loader.storage, sources_url, status="partial", type="nixguix"
     )
 
 
 def test_load_nixguix_one_common_artifact_from_other_loader(
     swh_config, datadir, requests_mock_datadir_visits, caplog
 ):
     """Misformatted revision should be caught and logged, then loading continues
 
     """
     caplog.set_level(logging.ERROR, "swh.loader.package.nixguix.loader")
 
     # 1. first ingest with for example the archive loader
     gnu_url = "https://ftp.gnu.org/gnu/8sync/"
     release = "0.1.0"
     artifact_url = f"https://ftp.gnu.org/gnu/8sync/8sync-{release}.tar.gz"
     gnu_artifacts = [
         {
             "time": 944729610,
             "url": artifact_url,
             "length": 221837,
             "filename": f"8sync-{release}.tar.gz",
             "version": release,
         }
     ]
     archive_loader = ArchiveLoader(url=gnu_url, artifacts=gnu_artifacts)
     actual_load_status = archive_loader.load()
     expected_snapshot_id = "c419397fd912039825ebdbea378bc6283f006bf5"
     assert actual_load_status["status"] == "eventful"
     assert actual_load_status["snapshot_id"] == expected_snapshot_id  # noqa
 
     assert_last_visit_matches(
         archive_loader.storage, gnu_url, status="full", type="tar"
     )
 
     gnu_snapshot: Snapshot = snapshot_get_all_branches(
         archive_loader.storage, hash_to_bytes(expected_snapshot_id)
     )
 
     first_revision = gnu_snapshot.branches[f"releases/{release}".encode("utf-8")]
 
     # 2. Then ingest with the nixguix loader which lists the same artifact within its
     # sources.json
 
     # ensure test setup is ok
     data_sources = os.path.join(
         datadir, "https_nix-community.github.io", "nixpkgs-swh_sources_special.json"
     )
     all_sources = json.loads(open(data_sources).read())
     found = False
     for source in all_sources["sources"]:
         if source["urls"][0] == artifact_url:
             found = True
             assert (
                 found is True
             ), f"test setup error: {artifact_url} must be in {data_sources}"
 
     # first visit with a snapshot, ok
     sources_url = "https://nix-community.github.io/nixpkgs-swh/sources_special.json"
     loader = NixGuixLoader(sources_url)
     actual_load_status2 = loader.load()
     assert actual_load_status2["status"] == "eventful"
 
     assert_last_visit_matches(
         loader.storage, sources_url, status="full", type="nixguix"
     )
 
     snapshot_id = actual_load_status2["snapshot_id"]
     snapshot = snapshot_get_all_branches(loader.storage, hash_to_bytes(snapshot_id))
     assert snapshot
 
     # simulate a snapshot already seen with a revision with the wrong metadata structure
     # This revision should be skipped, thus making the artifact being ingested again.
     with patch(
         "swh.loader.package.loader.PackageLoader.last_snapshot"
     ) as last_snapshot:
         # mutate the snapshot to target a revision with the wrong metadata structure
         # snapshot["branches"][artifact_url.encode("utf-8")] = first_revision
         old_revision = loader.storage.revision_get([first_revision.target])[0]
         # assert that revision is not in the right format
         assert old_revision.metadata["extrinsic"]["raw"].get("integrity", {}) == {}
 
         # mutate snapshot to create a clash
         snapshot = attr.evolve(
             snapshot,
             branches={
                 **snapshot.branches,
                 artifact_url.encode("utf-8"): SnapshotBranch(
                     target_type=TargetType.REVISION,
                     target=hash_to_bytes(old_revision.id),
                 ),
             },
         )
 
         # modify snapshot to actually change revision metadata structure so we simulate
         # a revision written by somebody else (structure different)
         last_snapshot.return_value = snapshot
 
         loader = NixGuixLoader(sources_url)
         actual_load_status3 = loader.load()
         assert last_snapshot.called
         assert actual_load_status3["status"] == "eventful"
 
         assert_last_visit_matches(
             loader.storage, sources_url, status="full", type="nixguix"
         )
 
         new_snapshot_id = "32ff641e510aceefc3a6d0dcbf208b2854d2e965"
         assert actual_load_status3["snapshot_id"] == new_snapshot_id
 
         last_snapshot = snapshot_get_all_branches(
             loader.storage, hash_to_bytes(new_snapshot_id)
         )
         new_revision_branch = last_snapshot.branches[artifact_url.encode("utf-8")]
         assert new_revision_branch.target_type == TargetType.REVISION
 
         new_revision = loader.storage.revision_get([new_revision_branch.target])[0]
 
         # the new revision has the correct structure,  so it got ingested alright by the
         # new run
         assert new_revision.metadata["extrinsic"]["raw"]["integrity"] is not None
 
         nb_detections = 0
         actual_detection: Dict
         for record in caplog.records:
             logtext = record.getMessage()
             if "Unexpected metadata revision structure detected:" in logtext:
                 nb_detections += 1
                 actual_detection = record.args["context"]
 
         assert actual_detection
         # as many calls as there are sources listed in the sources.json
         assert nb_detections == len(all_sources["sources"])
 
         assert actual_detection == {
             "revision": hash_to_hex(old_revision.id),
             "reason": "'integrity'",
             "known_artifact": old_revision.metadata,
         }
diff --git a/swh/loader/package/npm/loader.py b/swh/loader/package/npm/loader.py
index 348b036..5f5387a 100644
--- a/swh/loader/package/npm/loader.py
+++ b/swh/loader/package/npm/loader.py
@@ -1,339 +1,339 @@
-# Copyright (C) 2019-2020  The Software Heritage developers
+# Copyright (C) 2019-2021  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
 
 from codecs import BOM_UTF8
 import json
 import logging
 import os
 from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, Union
 from urllib.parse import quote
 
 import attr
 import chardet
 
 from swh.loader.package.loader import (
     BasePackageInfo,
     PackageLoader,
     RawExtrinsicMetadataCore,
 )
 from swh.loader.package.utils import api_info, cached_method, release_name
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     Person,
     Revision,
     RevisionType,
     Sha1Git,
     TimestampWithTimezone,
 )
 
 logger = logging.getLogger(__name__)
 
 
 EMPTY_PERSON = Person(fullname=b"", name=None, email=None)
 
 
 @attr.s
 class NpmPackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
 
     date = attr.ib(type=Optional[str])
     shasum = attr.ib(type=str)
     """sha1 checksum"""
     version = attr.ib(type=str)
 
     @classmethod
     def from_metadata(
         cls, project_metadata: Dict[str, Any], version: str
     ) -> "NpmPackageInfo":
         package_metadata = project_metadata["versions"][version]
         url = package_metadata["dist"]["tarball"]
 
         # No date available in intrinsic metadata: retrieve it from the API
         # metadata, using the version number that the API claims this package
         # has.
         extrinsic_version = package_metadata["version"]
 
         if "time" in project_metadata:
             date = project_metadata["time"][extrinsic_version]
         elif "mtime" in package_metadata:
             date = package_metadata["mtime"]
         else:
             date = None
 
         return cls(
             url=url,
             filename=os.path.basename(url),
             date=date,
             shasum=package_metadata["dist"]["shasum"],
             version=extrinsic_version,
             raw_info=package_metadata,
             directory_extrinsic_metadata=[
                 RawExtrinsicMetadataCore(
                     format="replicate-npm-package-json",
                     metadata=json.dumps(package_metadata).encode(),
                 )
             ],
         )
 
 
 class NpmLoader(PackageLoader[NpmPackageInfo]):
     """Load npm origin's artifact releases into swh archive.
 
     """
 
     visit_type = "npm"
 
     def __init__(self, url: str):
         """Constructor
 
         Args
             str: origin url (e.g. https://www.npmjs.com/package/<package-name>)
         """
         super().__init__(url=url)
         package_name = url.split("https://www.npmjs.com/package/")[1]
         safe_name = quote(package_name, safe="")
         self.provider_url = f"https://replicate.npmjs.com/{safe_name}/"
         self._info: Dict[str, Any] = {}
         self._versions = None
 
     @cached_method
     def _raw_info(self) -> bytes:
         return api_info(self.provider_url)
 
     @cached_method
     def info(self) -> Dict:
         """Return the project metadata information (fetched from npm registry)
 
         """
         return json.loads(self._raw_info())
 
     def get_versions(self) -> Sequence[str]:
         return sorted(list(self.info()["versions"].keys()))
 
     def get_default_version(self) -> str:
         return self.info()["dist-tags"].get("latest", "")
 
     def get_metadata_authority(self):
         return MetadataAuthority(
             type=MetadataAuthorityType.FORGE, url="https://npmjs.com/", metadata={},
         )
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, NpmPackageInfo]]:
         p_info = NpmPackageInfo.from_metadata(
             project_metadata=self.info(), version=version
         )
         yield release_name(version), p_info
 
     def resolve_revision_from(
         self, known_artifacts: Dict, p_info: NpmPackageInfo
     ) -> Optional[bytes]:
         return artifact_to_revision_id(known_artifacts, p_info)
 
     def build_revision(
         self, p_info: NpmPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Revision]:
         i_metadata = extract_intrinsic_metadata(uncompressed_path)
         if not i_metadata:
             return None
         author = extract_npm_package_author(i_metadata)
         message = i_metadata["version"].encode("ascii")
 
         if p_info.date is None:
             url = p_info.url
             artifact_name = os.path.basename(url)
             raise ValueError(
                 "Origin %s: Cannot determine upload time for artifact %s."
                 % (p_info.url, artifact_name)
             )
 
         date = TimestampWithTimezone.from_iso8601(p_info.date)
 
         # FIXME: this is to remain bug-compatible with earlier versions:
         date = attr.evolve(date, timestamp=attr.evolve(date.timestamp, microseconds=0))
 
         r = Revision(
             type=RevisionType.TAR,
             message=message,
             author=author,
             date=date,
             committer=author,
             committer_date=date,
             parents=(),
             directory=directory,
             synthetic=True,
             metadata={
                 "intrinsic": {"tool": "package.json", "raw": i_metadata,},
                 "extrinsic": {
                     "provider": self.provider_url,
                     "when": self.visit_date.isoformat(),
                     "raw": p_info.raw_info,
                 },
             },
         )
         return r
 
 
 def artifact_to_revision_id(
     known_artifacts: Dict, p_info: NpmPackageInfo
 ) -> Optional[bytes]:
     """Given metadata artifact, solves the associated revision id.
 
     The following code allows to deal with 2 metadata formats:
 
     - old format sample::
 
         {
             'package_source': {
                 'sha1': '05181c12cd8c22035dd31155656826b85745da37',
             }
         }
 
     - new format sample::
 
         {
             'original_artifact': [{
                 'checksums': {
                     'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec', # noqa
                     ...
                 },
             }],
             ...
         }
 
     """
     shasum = p_info.shasum
     for rev_id, known_artifact in known_artifacts.items():
         known_original_artifact = known_artifact.get("original_artifact")
         if not known_original_artifact:
             # previous loader-npm version kept original artifact elsewhere
             known_original_artifact = known_artifact.get("package_source")
             if not known_original_artifact:
                 continue
             original_hash = known_original_artifact["sha1"]
         else:
             assert isinstance(known_original_artifact, list)
             original_hash = known_original_artifact[0]["checksums"]["sha1"]
         if shasum == original_hash:
             return rev_id
     return None
 
 
 def _author_str(author_data: Union[Dict, List, str]) -> str:
     """Parse author from package.json author fields
 
     """
     if isinstance(author_data, dict):
         author_str = ""
         name = author_data.get("name")
         if name is not None:
             if isinstance(name, str):
                 author_str += name
             elif isinstance(name, list):
                 author_str += _author_str(name[0]) if len(name) > 0 else ""
         email = author_data.get("email")
         if email is not None:
             author_str += f" <{email}>"
         result = author_str
     elif isinstance(author_data, list):
         result = _author_str(author_data[0]) if len(author_data) > 0 else ""
     else:
         result = author_data
     return result
 
 
 def extract_npm_package_author(package_json: Dict[str, Any]) -> Person:
     """
     Extract package author from a ``package.json`` file content and
     return it in swh format.
 
     Args:
         package_json: Dict holding the content of parsed
             ``package.json`` file
 
     Returns:
         Person
 
     """
     for author_key in ("author", "authors"):
         if author_key in package_json:
             author_data = package_json[author_key]
             if author_data is None:
                 return EMPTY_PERSON
             author_str = _author_str(author_data)
             return Person.from_fullname(author_str.encode())
 
     return EMPTY_PERSON
 
 
 def _lstrip_bom(s, bom=BOM_UTF8):
     if s.startswith(bom):
         return s[len(bom) :]
     else:
         return s
 
 
 def load_json(json_bytes):
     """
     Try to load JSON from bytes and return a dictionary.
 
     First try to decode from utf-8. If the decoding failed,
     try to detect the encoding and decode again with replace
     error handling.
 
     If JSON is malformed, an empty dictionary will be returned.
 
     Args:
         json_bytes (bytes): binary content of a JSON file
 
     Returns:
         dict: JSON data loaded in a dictionary
     """
     json_data = {}
     try:
         json_str = _lstrip_bom(json_bytes).decode("utf-8")
     except UnicodeDecodeError:
         encoding = chardet.detect(json_bytes)["encoding"]
         if encoding:
             json_str = json_bytes.decode(encoding, "replace")
     try:
         json_data = json.loads(json_str)
     except json.decoder.JSONDecodeError:
         pass
     return json_data
 
 
 def extract_intrinsic_metadata(dir_path: str) -> Dict:
     """Given an uncompressed path holding the pkginfo file, returns a
        pkginfo parsed structure as a dict.
 
        The release artifact contains at their root one folder. For example:
        $ tar tvf zprint-0.0.6.tar.gz
        drwxr-xr-x root/root         0 2018-08-22 11:01 zprint-0.0.6/
        ...
 
     Args:
 
         dir_path (str): Path to the uncompressed directory
                         representing a release artifact from npm.
 
     Returns:
         the pkginfo parsed structure as a dict if any or None if
         none was present.
 
     """
     # Retrieve the root folder of the archive
     if not os.path.exists(dir_path):
         return {}
     lst = os.listdir(dir_path)
     if len(lst) == 0:
         return {}
     project_dirname = lst[0]
     package_json_path = os.path.join(dir_path, project_dirname, "package.json")
     if not os.path.exists(package_json_path):
         return {}
     with open(package_json_path, "rb") as package_json_file:
         package_json_bytes = package_json_file.read()
         return load_json(package_json_bytes)
diff --git a/swh/loader/package/npm/tests/test_npm.py b/swh/loader/package/npm/tests/test_npm.py
index e35ad70..13e2bc1 100644
--- a/swh/loader/package/npm/tests/test_npm.py
+++ b/swh/loader/package/npm/tests/test_npm.py
@@ -1,703 +1,714 @@
 # Copyright (C) 2019-2021  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.loader.package import __version__
 from swh.loader.package.npm.loader import (
     NpmLoader,
     _author_str,
     artifact_to_revision_id,
     extract_npm_package_author,
 )
 from swh.loader.package.tests.common import check_metadata_paths
 from swh.loader.tests import assert_last_visit_matches, check_snapshot, get_stats
 from swh.model.hashutil import hash_to_bytes
 from swh.model.identifiers import SWHID
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     MetadataFetcher,
     MetadataTargetType,
     Person,
     RawExtrinsicMetadata,
     Snapshot,
     SnapshotBranch,
     TargetType,
 )
 from swh.storage.interface import PagedResult
 
 
 @pytest.fixture
 def org_api_info(datadir) -> bytes:
     with open(os.path.join(datadir, "https_replicate.npmjs.com", "org"), "rb",) as f:
         return f.read()
 
 
 def test_npm_author_str():
     for author, expected_author in [
         ("author", "author"),
         (
             ["Al from quantum leap", "hal from 2001 space odyssey"],
             "Al from quantum leap",
         ),
         ([], ""),
         ({"name": "groot", "email": "groot@galaxy.org",}, "groot <groot@galaxy.org>"),
         ({"name": "somebody",}, "somebody"),
         ({"email": "no@one.org"}, " <no@one.org>"),  # note first elt is an extra blank
         ({"name": "no one", "email": None,}, "no one"),
         ({"email": None,}, ""),
         ({"name": None}, ""),
         ({"name": None, "email": None,}, ""),
         ({}, ""),
         (None, None),
         ({"name": []}, "",),
         (
             {"name": ["Susan McSween", "William H. Bonney", "Doc Scurlock",]},
             "Susan McSween",
         ),
         (None, None),
     ]:
         assert _author_str(author) == expected_author
 
 
 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/"
     }"""
     )
 
     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",
     )
 
     package_json_no_authors = json.loads(
         """{
         "authors": null,
         "license": "MIT"
     }"""
     )
 
     assert extract_npm_package_author(package_json_no_authors) == Person(
         fullname=b"", name=None, email=None
     )
 
 
 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 = 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, org_api_info):
     package = "org"
     url = package_url(package)
     loader = NpmLoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = hash_to_bytes("d0587e1195aed5a8800411a008f2f2d627f18e2d")
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="npm", snapshot=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,
         "release": 0,
         "revision": len(_expected_new_revisions_first_visit),
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     contents = loader.storage.content_get(_expected_new_contents_first_visit)
     count = sum(0 if content is None else 1 for content in contents)
     assert count == 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)) == []
     )
 
     versions = [
         ("0.0.2", "d8a1c7474d2956ac598a19f0f27d52f7015f117e"),
         ("0.0.3", "5f9eb78af37ffd12949f235e86fac04898f9f72a"),
         ("0.0.4", "ba019b192bdb94bd0b5bd68b3a5f92b5acc2239a"),
     ]
 
     expected_snapshot = Snapshot(
         id=expected_snapshot_id,
         branches={
             b"HEAD": SnapshotBranch(
                 target=b"releases/0.0.4", target_type=TargetType.ALIAS
             ),
             **{
                 b"releases/"
                 + version_name.encode(): SnapshotBranch(
                     target=hash_to_bytes(version_id), target_type=TargetType.REVISION,
                 )
                 for (version_name, version_id) in versions
             },
         },
     )
     check_snapshot(expected_snapshot, loader.storage)
 
     metadata_authority = MetadataAuthority(
         type=MetadataAuthorityType.FORGE, url="https://npmjs.com/",
     )
 
     for (version_name, revision_id) in versions:
         revision = loader.storage.revision_get([hash_to_bytes(revision_id)])[0]
         directory_id = revision.directory
         directory_swhid = SWHID(object_type="directory", object_id=directory_id,)
         revision_swhid = SWHID(object_type="revision", object_id=revision_id,)
         expected_metadata = [
             RawExtrinsicMetadata(
                 type=MetadataTargetType.DIRECTORY,
                 target=directory_swhid,
                 authority=metadata_authority,
                 fetcher=MetadataFetcher(
                     name="swh.loader.package.npm.loader.NpmLoader", version=__version__,
                 ),
                 discovery_date=loader.visit_date,
                 format="replicate-npm-package-json",
                 metadata=json.dumps(
                     json.loads(org_api_info)["versions"][version_name]
                 ).encode(),
                 origin="https://www.npmjs.com/package/org",
                 revision=revision_swhid,
             )
         ]
         assert loader.storage.raw_extrinsic_metadata_get(
             MetadataTargetType.DIRECTORY, directory_swhid, metadata_authority,
         ) == PagedResult(next_page_token=None, results=expected_metadata,)
 
 
 def test_npm_loader_incremental_visit(swh_config, requests_mock_datadir_visits):
     package = "org"
     url = package_url(package)
     loader = NpmLoader(url)
 
     expected_snapshot_id = hash_to_bytes("d0587e1195aed5a8800411a008f2f2d627f18e2d")
     actual_load_status = loader.load()
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
     assert_last_visit_matches(
         loader.storage, url, status="full", type="npm", snapshot=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,
         "release": 0,
         "revision": len(_expected_new_revisions_first_visit),
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     # reset loader internal state
     del loader._cached_info
     del loader._cached__raw_info
 
     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"]
 
     assert_last_visit_matches(loader.storage, url, status="full", 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,
         "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()
     expected_snapshot_id = hash_to_bytes("b11ebac8c9d0c9e5063a2df693a18e3aba4b2f92")
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
     assert_last_visit_matches(
         loader.storage, url, status="full", type="npm", snapshot=expected_snapshot_id
     )
 
     stats = get_stats(loader.storage)
 
     assert {  # 1 new releases artifacts
         "content": 534,
         "directory": 153,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 2,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     expected_snapshot = Snapshot(
         id=expected_snapshot_id,
         branches={
             b"HEAD": SnapshotBranch(
                 target_type=TargetType.ALIAS, target=b"releases/0.1.0"
             ),
             b"releases/0.1.0": SnapshotBranch(
                 target_type=TargetType.REVISION,
                 target=hash_to_bytes("845673bfe8cbd31b1eaf757745a964137e6f9116"),
             ),
             b"releases/0.1.1-alpha.14": SnapshotBranch(
                 target_type=TargetType.REVISION,
                 target=hash_to_bytes("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
 
     """
 
     class artifact_metadata:
         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
 
     """
 
     class artifact_metadata:
         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
 
     """
 
     class artifact_metadata:
         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()
     # no branch as one artifact without any intrinsic metadata
     expected_snapshot = Snapshot(
         id=hash_to_bytes("1a8893e6a86f444e8be8e7bda6cb34fb1735a00e"), branches={},
     )
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot.id.hex(),
     }
 
     check_snapshot(expected_snapshot, loader.storage)
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="npm", snapshot=expected_snapshot.id
     )
 
 
 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()
     # no branch as one artifact without any intrinsic metadata
     expected_snapshot = Snapshot(
         id=hash_to_bytes("1a8893e6a86f444e8be8e7bda6cb34fb1735a00e"), branches={},
     )
     assert actual_load_status == {
         "status": "uneventful",
         "snapshot_id": expected_snapshot.id.hex(),
     }
 
     check_snapshot(expected_snapshot, loader.storage)
 
     assert_last_visit_matches(
         loader.storage, url, status="partial", type="npm", snapshot=expected_snapshot.id
     )
 
 
 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()
     expected_snapshot_id = hash_to_bytes("d6e08e19159f77983242877c373c75222d5ae9dd")
 
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
 
     # artifact is used
     expected_snapshot = Snapshot(
         id=expected_snapshot_id,
         branches={
             b"HEAD": SnapshotBranch(
                 target_type=TargetType.ALIAS, target=b"releases/0.0.1"
             ),
             b"releases/0.0.1": SnapshotBranch(
                 target_type=TargetType.REVISION,
                 target=hash_to_bytes("9e4dd2b40d1b46b70917c0949aa2195c823a648e"),
             ),
         },
     )
     check_snapshot(expected_snapshot, loader.storage)
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="npm", snapshot=expected_snapshot.id
     )
 
 
 def test_npm_no_artifact(swh_config, requests_mock_datadir):
     """If no artifacts at all is found for origin, the visit fails completely
 
     """
     package = "catify"
     url = package_url(package)
     loader = NpmLoader(url)
     actual_load_status = loader.load()
     assert actual_load_status == {
         "status": "failed",
     }
 
     assert_last_visit_matches(loader.storage, url, status="failed", type="npm")
+
+
+def test_npm_origin_not_found(swh_config, requests_mock_datadir):
+    url = package_url("non-existent-url")
+    loader = NpmLoader(url)
+
+    assert loader.load() == {"status": "failed"}
+
+    assert_last_visit_matches(
+        loader.storage, url, status="not_found", type="npm", snapshot=None
+    )
diff --git a/swh/loader/package/pypi/loader.py b/swh/loader/package/pypi/loader.py
index fa88084..6936c36 100644
--- a/swh/loader/package/pypi/loader.py
+++ b/swh/loader/package/pypi/loader.py
@@ -1,284 +1,284 @@
-# Copyright (C) 2019-2020  The Software Heritage developers
+# Copyright (C) 2019-2021  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 logging
 import os
 from typing import Any, Dict, Iterator, Optional, Sequence, Tuple
 from urllib.parse import urlparse
 
 import attr
 from pkginfo import UnpackedSDist
 
 from swh.loader.package.loader import (
     BasePackageInfo,
     PackageLoader,
     RawExtrinsicMetadataCore,
 )
 from swh.loader.package.utils import EMPTY_AUTHOR, api_info, cached_method, release_name
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     Person,
     Revision,
     RevisionType,
     Sha1Git,
     TimestampWithTimezone,
 )
 
 logger = logging.getLogger(__name__)
 
 
 @attr.s
 class PyPIPackageInfo(BasePackageInfo):
     raw_info = attr.ib(type=Dict[str, Any])
 
     comment_text = attr.ib(type=Optional[str])
     sha256 = attr.ib(type=str)
     upload_time = attr.ib(type=str)
 
     @classmethod
     def from_metadata(cls, metadata: Dict[str, Any]) -> "PyPIPackageInfo":
         return cls(
             url=metadata["url"],
             filename=metadata["filename"],
             raw_info=metadata,
             comment_text=metadata.get("comment_text"),
             sha256=metadata["digests"]["sha256"],
             upload_time=metadata["upload_time"],
             directory_extrinsic_metadata=[
                 RawExtrinsicMetadataCore(
                     format="pypi-project-json", metadata=json.dumps(metadata).encode(),
                 )
             ],
         )
 
 
 class PyPILoader(PackageLoader[PyPIPackageInfo]):
     """Load pypi origin's artifact releases into swh archive.
 
     """
 
     visit_type = "pypi"
 
     def __init__(self, url):
         super().__init__(url=url)
         self.provider_url = pypi_api_url(self.url)
 
     @cached_method
     def _raw_info(self) -> bytes:
         return api_info(self.provider_url)
 
     @cached_method
     def info(self) -> Dict:
         """Return the project metadata information (fetched from pypi registry)
 
         """
         return json.loads(self._raw_info())
 
     def get_versions(self) -> Sequence[str]:
         return self.info()["releases"].keys()
 
     def get_default_version(self) -> str:
         return self.info()["info"]["version"]
 
     def get_metadata_authority(self):
         p_url = urlparse(self.url)
         return MetadataAuthority(
             type=MetadataAuthorityType.FORGE,
             url=f"{p_url.scheme}://{p_url.netloc}/",
             metadata={},
         )
 
     def get_package_info(self, version: str) -> Iterator[Tuple[str, PyPIPackageInfo]]:
         res = []
         for meta in self.info()["releases"][version]:
             if meta["packagetype"] != "sdist":
                 continue
             p_info = PyPIPackageInfo.from_metadata(meta)
             res.append((version, p_info))
 
         if len(res) == 1:
             version, p_info = res[0]
             yield release_name(version), p_info
         else:
             for version, p_info in res:
                 yield release_name(version, p_info.filename), p_info
 
     def resolve_revision_from(
         self, known_artifacts: Dict, p_info: PyPIPackageInfo
     ) -> Optional[bytes]:
         return artifact_to_revision_id(known_artifacts, p_info)
 
     def build_revision(
         self, p_info: PyPIPackageInfo, uncompressed_path: str, directory: Sha1Git
     ) -> Optional[Revision]:
         i_metadata = extract_intrinsic_metadata(uncompressed_path)
         if not i_metadata:
             return None
 
         # from intrinsic metadata
         name = i_metadata["version"]
         _author = author(i_metadata)
 
         # from extrinsic metadata
         message = p_info.comment_text or ""
         message = "%s: %s" % (name, message) if message else name
         date = TimestampWithTimezone.from_iso8601(p_info.upload_time)
 
         return Revision(
             type=RevisionType.TAR,
             message=message.encode("utf-8"),
             author=_author,
             date=date,
             committer=_author,
             committer_date=date,
             parents=(),
             directory=directory,
             synthetic=True,
             metadata={
                 "intrinsic": {"tool": "PKG-INFO", "raw": i_metadata,},
                 "extrinsic": {
                     "provider": self.provider_url,
                     "when": self.visit_date.isoformat(),
                     "raw": p_info.raw_info,
                 },
             },
         )
 
 
 def artifact_to_revision_id(
     known_artifacts: Dict, p_info: PyPIPackageInfo
 ) -> Optional[bytes]:
     """Given metadata artifact, solves the associated revision id.
 
     The following code allows to deal with 2 metadata formats (column metadata
     in 'revision')
 
     - old format sample::
 
         {
             'original_artifact': {
                 'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec',  # noqa
                 ...
             },
             ...
         }
 
     - new format sample::
 
         {
             'original_artifact': [{
                 'checksums': {
                     'sha256': '6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec',  # noqa
                     ...
                 },
             }],
             ...
         }
 
     """
     sha256 = p_info.sha256
     for rev_id, known_artifact in known_artifacts.items():
         original_artifact = known_artifact["original_artifact"]
         if isinstance(original_artifact, dict):
             # previous loader-pypi version stored metadata as dict
             original_sha256 = original_artifact["sha256"]
             if sha256 == original_sha256:
                 return rev_id
             continue
         # new pypi loader actually store metadata dict differently...
         assert isinstance(original_artifact, list)
         # current loader-pypi stores metadata as list of dict
         for original_artifact in known_artifact["original_artifact"]:
             if sha256 == original_artifact["checksums"]["sha256"]:
                 return rev_id
     return None
 
 
 def pypi_api_url(url: str) -> str:
     """Compute api url from a project url
 
     Args:
         url (str): PyPI instance's url (e.g: https://pypi.org/project/requests)
         This deals with correctly transforming the project's api url (e.g
         https://pypi.org/pypi/requests/json)
 
     Returns:
         api url
 
     """
     p_url = urlparse(url)
     project_name = p_url.path.rstrip("/").split("/")[-1]
     url = "%s://%s/pypi/%s/json" % (p_url.scheme, p_url.netloc, project_name)
     return url
 
 
 def extract_intrinsic_metadata(dir_path: str) -> Dict:
     """Given an uncompressed path holding the pkginfo file, returns a
        pkginfo parsed structure as a dict.
 
        The release artifact contains at their root one folder. For example:
        $ tar tvf zprint-0.0.6.tar.gz
        drwxr-xr-x root/root         0 2018-08-22 11:01 zprint-0.0.6/
        ...
 
     Args:
 
         dir_path (str): Path to the uncompressed directory
                         representing a release artifact from pypi.
 
     Returns:
         the pkginfo parsed structure as a dict if any or None if
         none was present.
 
     """
     # Retrieve the root folder of the archive
     if not os.path.exists(dir_path):
         return {}
     lst = os.listdir(dir_path)
     if len(lst) != 1:
         return {}
     project_dirname = lst[0]
     pkginfo_path = os.path.join(dir_path, project_dirname, "PKG-INFO")
     if not os.path.exists(pkginfo_path):
         return {}
     pkginfo = UnpackedSDist(pkginfo_path)
     raw = pkginfo.__dict__
     raw.pop("filename")  # this gets added with the ondisk location
     return raw
 
 
 def author(data: Dict) -> Person:
     """Given a dict of project/release artifact information (coming from
        PyPI), returns an author subset.
 
     Args:
         data (dict): Representing either artifact information or
                      release information.
 
     Returns:
         swh-model dict representing a person.
 
     """
     name = data.get("author")
     email = data.get("author_email")
     fullname = None  # type: Optional[str]
 
     if email:
         fullname = "%s <%s>" % (name, email)
     else:
         fullname = name
 
     if not fullname:
         return EMPTY_AUTHOR
 
     if name is not None:
         name = name.encode("utf-8")
 
     if email is not None:
         email = email.encode("utf-8")
 
     return Person(fullname=fullname.encode("utf-8"), name=name, email=email)
diff --git a/swh/loader/package/pypi/tests/test_pypi.py b/swh/loader/package/pypi/tests/test_pypi.py
index e0fe6cc..b55df1f 100644
--- a/swh/loader/package/pypi/tests/test_pypi.py
+++ b/swh/loader/package/pypi/tests/test_pypi.py
@@ -1,906 +1,917 @@
 # Copyright (C) 2019-2021 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 copy
 import json
 import os
 from os import path
 from unittest.mock import patch
 
 import pytest
 import yaml
 
 from swh.core.pytest_plugin import requests_mock_datadir_factory
 from swh.core.tarball import uncompress
 from swh.loader.package import __version__
 from swh.loader.package.pypi.loader import (
     PyPILoader,
     artifact_to_revision_id,
     author,
     extract_intrinsic_metadata,
     pypi_api_url,
 )
 from swh.loader.package.tests.common import check_metadata_paths
 from swh.loader.tests import assert_last_visit_matches, check_snapshot, get_stats
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.identifiers import SWHID
 from swh.model.model import (
     MetadataAuthority,
     MetadataAuthorityType,
     MetadataFetcher,
     MetadataTargetType,
     Person,
     RawExtrinsicMetadata,
     Snapshot,
     SnapshotBranch,
     TargetType,
 )
 from swh.storage.interface import PagedResult
 
 
 @pytest.fixture
 def _0805nexter_api_info(datadir) -> bytes:
     with open(
         os.path.join(datadir, "https_pypi.org", "pypi_0805nexter_json"), "rb",
     ) as f:
         return f.read()
 
 
 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(tmp_path, swh_loader_config, monkeypatch):
     """Badly configured loader should raise"""
     wrong_config = copy.deepcopy(swh_loader_config)
     wrong_config.pop("storage")
 
     conf_path = os.path.join(str(tmp_path), "loader.yml")
     with open(conf_path, "w") as f:
         f.write(yaml.dump(wrong_config))
     monkeypatch.setenv("SWH_CONFIG_FILENAME", conf_path)
 
     with pytest.raises(ValueError, match="Misconfiguration"):
         PyPILoader(url="some-url")
 
 
 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,
         "release": 0,
         "revision": 0,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     assert_last_visit_matches(loader.storage, url, status="partial", type="pypi")
 
 
 def test_pypi_fail__load_snapshot(swh_config, requests_mock_datadir):
     """problem during loading: {visit: failed, status: failed, no snapshot}
 
     """
     url = "https://pypi.org/project/0805nexter"
     with patch(
         "swh.loader.package.pypi.loader.PyPILoader._load_snapshot",
         side_effect=ValueError("Fake problem to fail visit"),
     ):
         loader = PyPILoader(url)
 
         actual_load_status = loader.load()
         assert actual_load_status == {"status": "failed"}
 
         stats = get_stats(loader.storage)
 
         assert {
             "content": 6,
             "directory": 4,
             "origin": 1,
             "origin_visit": 1,
             "release": 0,
             "revision": 2,
             "skipped_content": 0,
             "snapshot": 0,
         } == stats
 
         assert_last_visit_matches(loader.storage, url, status="failed", 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"}
 
         stats = get_stats(loader.storage)
 
         assert {
             "content": 0,
             "directory": 0,
             "origin": 1,
             "origin_visit": 1,
             "release": 0,
             "revision": 0,
             "skipped_content": 0,
             "snapshot": 0,
         } == stats
 
         assert_last_visit_matches(loader.storage, url, status="failed", 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, _0805nexter_api_info
 ):
     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 = 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),],
         )
 
     revision_swhid = SWHID(
         object_type="revision", object_id=hash_to_hex(expected_revision_id)
     )
     directory_swhid = SWHID(
         object_type="directory", object_id=hash_to_hex(revision.directory)
     )
     metadata_authority = MetadataAuthority(
         type=MetadataAuthorityType.FORGE, url="https://pypi.org/",
     )
     expected_metadata = [
         RawExtrinsicMetadata(
             type=MetadataTargetType.DIRECTORY,
             target=directory_swhid,
             authority=metadata_authority,
             fetcher=MetadataFetcher(
                 name="swh.loader.package.pypi.loader.PyPILoader", version=__version__,
             ),
             discovery_date=loader.visit_date,
             format="pypi-project-json",
             metadata=json.dumps(
                 json.loads(_0805nexter_api_info)["releases"]["1.2.0"][0]
             ).encode(),
             origin=url,
             revision=revision_swhid,
         )
     ]
     assert loader.storage.raw_extrinsic_metadata_get(
         MetadataTargetType.DIRECTORY, directory_swhid, metadata_authority,
     ) == PagedResult(next_page_token=None, results=expected_metadata,)
 
 
 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 = hash_to_bytes("dd0e4201a232b1c104433741dbf45895b8ac9355")
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
 
     stats = get_stats(loader.storage)
 
     assert {
         "content": 3,
         "directory": 2,
         "origin": 1,
         "origin_visit": 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_snapshot = Snapshot(
         id=hash_to_bytes(expected_snapshot_id),
         branches={
             b"releases/1.2.0": SnapshotBranch(
                 target=hash_to_bytes("e445da4da22b31bfebb6ffc4383dbf839a074d21"),
                 target_type=TargetType.REVISION,
             ),
             b"HEAD": SnapshotBranch(
                 target=b"releases/1.2.0", target_type=TargetType.ALIAS,
             ),
         },
     )
     check_snapshot(expected_snapshot, storage=loader.storage)
 
     assert_last_visit_matches(
         loader.storage,
         url,
         status="partial",
         type="pypi",
         snapshot=expected_snapshot_id,
     )
 
 
 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 = hash_to_bytes("ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a")
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
 
     stats = get_stats(loader.storage)
     assert {
         "content": 6,
         "directory": 4,
         "origin": 1,
         "origin_visit": 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_snapshot = Snapshot(
         id=expected_snapshot_id,
         branches={
             b"releases/1.1.0": SnapshotBranch(
                 target=hash_to_bytes("4c99891f93b81450385777235a37b5e966dd1571"),
                 target_type=TargetType.REVISION,
             ),
             b"releases/1.2.0": SnapshotBranch(
                 target=hash_to_bytes("e445da4da22b31bfebb6ffc4383dbf839a074d21"),
                 target_type=TargetType.REVISION,
             ),
             b"HEAD": SnapshotBranch(
                 target=b"releases/1.2.0", target_type=TargetType.ALIAS,
             ),
         },
     )
     check_snapshot(expected_snapshot, loader.storage)
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi", snapshot=expected_snapshot_id
     )
 
 
 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 = hash_to_bytes("ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a")
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": snapshot_id.hex(),
     }
     assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi", snapshot=snapshot_id
     )
 
     stats = get_stats(loader.storage)
 
     assert {
         "content": 6,
         "directory": 4,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 2,
         "skipped_content": 0,
         "snapshot": 1,
     } == stats
 
     expected_snapshot = Snapshot(
         id=snapshot_id,
         branches={
             b"releases/1.1.0": SnapshotBranch(
                 target=hash_to_bytes("4c99891f93b81450385777235a37b5e966dd1571"),
                 target_type=TargetType.REVISION,
             ),
             b"releases/1.2.0": SnapshotBranch(
                 target=hash_to_bytes("e445da4da22b31bfebb6ffc4383dbf839a074d21"),
                 target_type=TargetType.REVISION,
             ),
             b"HEAD": SnapshotBranch(
                 target=b"releases/1.2.0", target_type=TargetType.ALIAS,
             ),
         },
     )
     check_snapshot(expected_snapshot, loader.storage)
 
     actual_load_status2 = loader.load()
     assert actual_load_status2 == {
         "status": "uneventful",
         "snapshot_id": actual_load_status2["snapshot_id"],
     }
 
     visit_status2 = assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi"
     )
 
     stats2 = get_stats(loader.storage)
     expected_stats2 = stats.copy()
     expected_stats2["origin_visit"] = 1 + 1
     assert expected_stats2 == stats2
 
     # same snapshot
     assert visit_status2.snapshot == 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 = hash_to_bytes("ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a")
     assert visit1_actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi", snapshot=expected_snapshot_id
     )
 
     assert {
         "content": 6,
         "directory": 4,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 2,
         "skipped_content": 0,
         "snapshot": 1,
     } == visit1_stats
 
     # Reset internal state
     del loader._cached__raw_info
     del loader._cached_info
 
     visit2_actual_load_status = loader.load()
     visit2_stats = get_stats(loader.storage)
 
     assert visit2_actual_load_status["status"] == "eventful", visit2_actual_load_status
     expected_snapshot_id2 = hash_to_bytes("2e5149a7b0725d18231a37b342e9b7c4e121f283")
     assert visit2_actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id2.hex(),
     }
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi", snapshot=expected_snapshot_id2
     )
 
     assert {
         "content": 6 + 1,  # 1 more content
         "directory": 4 + 2,  # 2 more directories
         "origin": 1,
         "origin_visit": 1 + 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_snapshot = Snapshot(
         id=expected_snapshot_id2,
         branches={
             b"releases/1.1.0": SnapshotBranch(
                 target=hash_to_bytes("4c99891f93b81450385777235a37b5e966dd1571"),
                 target_type=TargetType.REVISION,
             ),
             b"releases/1.2.0": SnapshotBranch(
                 target=hash_to_bytes("e445da4da22b31bfebb6ffc4383dbf839a074d21"),
                 target_type=TargetType.REVISION,
             ),
             b"releases/1.3.0": SnapshotBranch(
                 target=hash_to_bytes("51247143b01445c9348afa9edfae31bf7c5d86b1"),
                 target_type=TargetType.REVISION,
             ),
             b"HEAD": SnapshotBranch(
                 target=b"releases/1.3.0", target_type=TargetType.ALIAS,
             ),
         },
     )
 
     check_snapshot(expected_snapshot, loader.storage)
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi", snapshot=expected_snapshot.id
     )
 
     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 = hash_to_bytes("a27e638a4dad6fbfa273c6ebec1c4bf320fb84c6")
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
 
     expected_snapshot = Snapshot(
         id=expected_snapshot_id,
         branches={
             b"releases/1.1.0/nexter-1.1.0.zip": SnapshotBranch(
                 target=hash_to_bytes("4c99891f93b81450385777235a37b5e966dd1571"),
                 target_type=TargetType.REVISION,
             ),
             b"releases/1.1.0/nexter-1.1.0.tar.gz": SnapshotBranch(
                 target=hash_to_bytes("0bf88f5760cca7665d0af4d6575d9301134fe11a"),
                 target_type=TargetType.REVISION,
             ),
         },
     )
     check_snapshot(expected_snapshot, loader.storage)
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi", snapshot=expected_snapshot.id
     )
 
 
 def test_pypi_artifact_to_revision_id_none():
     """Current loader version should stop soon if nothing can be found
 
     """
 
     class artifact_metadata:
         sha256 = "6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec"
 
     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
 
     """
 
     class artifact_metadata:
         sha256 = "6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec"
 
     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
 
     """
 
     class artifact_metadata:
         sha256 = "6975816f2c5ad4046acc676ba112f2fff945b01522d63948531f11f11e0892ec"
 
     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_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 = hash_to_bytes("1a8893e6a86f444e8be8e7bda6cb34fb1735a00e")
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": expected_snapshot_id.hex(),
     }
 
     # no branch as one artifact without any intrinsic metadata
     expected_snapshot = Snapshot(id=expected_snapshot_id, branches={})
     check_snapshot(expected_snapshot, loader.storage)
 
     assert_last_visit_matches(
         loader.storage, url, status="full", type="pypi", snapshot=expected_snapshot.id
     )
+
+
+def test_pypi_origin_not_found(swh_config, requests_mock_datadir):
+    url = "https://pypi.org/project/unknown"
+    loader = PyPILoader(url)
+
+    assert loader.load() == {"status": "failed"}
+
+    assert_last_visit_matches(
+        loader.storage, url, status="not_found", type="pypi", snapshot=None
+    )
diff --git a/swh/loader/package/tests/test_utils.py b/swh/loader/package/tests/test_utils.py
index 6c11909..5b5a544 100644
--- a/swh/loader/package/tests/test_utils.py
+++ b/swh/loader/package/tests/test_utils.py
@@ -1,159 +1,160 @@
-# Copyright (C) 2019-2020  The Software Heritage developers
+# Copyright (C) 2019-2021  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.loader.exception import NotFound
 import swh.loader.package
 from swh.loader.package.utils import api_info, download, release_name
 
 
 def test_version_generation():
     assert (
         swh.loader.package.__version__ != "devel"
     ), "Make sure swh.loader.core is installed (e.g. pip install -e .)"
 
 
 @pytest.mark.fs
 def test_download_fail_to_download(tmp_path, requests_mock):
     url = "https://pypi.org/pypi/arrow/json"
     status_code = 404
     requests_mock.get(url, status_code=status_code)
 
     with pytest.raises(ValueError) as e:
         download(url, tmp_path)
 
     assert e.value.args[0] == "Fail to query '%s'. Reason: %s" % (url, status_code)
 
 
 @pytest.mark.fs
 def test_download_ok(tmp_path, requests_mock):
     """Download without issue should provide filename and hashes"""
     filename = "requests-0.0.1.tar.gz"
     url = "https://pypi.org/pypi/requests/%s" % filename
     data = "this is something"
     requests_mock.get(url, text=data, headers={"content-length": str(len(data))})
 
     actual_filepath, actual_hashes = download(url, dest=str(tmp_path))
 
     actual_filename = os.path.basename(actual_filepath)
     assert actual_filename == filename
     assert actual_hashes["length"] == len(data)
     assert (
         actual_hashes["checksums"]["sha1"] == "fdd1ce606a904b08c816ba84f3125f2af44d92b2"
     )  # noqa
     assert (
         actual_hashes["checksums"]["sha256"]
         == "1d9224378d77925d612c9f926eb9fb92850e6551def8328011b6a972323298d5"
     )
 
 
 @pytest.mark.fs
 def test_download_ok_no_header(tmp_path, requests_mock):
     """Download without issue should provide filename and hashes"""
     filename = "requests-0.0.1.tar.gz"
     url = "https://pypi.org/pypi/requests/%s" % filename
     data = "this is something"
     requests_mock.get(url, text=data)  # no header information
 
     actual_filepath, actual_hashes = download(url, dest=str(tmp_path))
 
     actual_filename = os.path.basename(actual_filepath)
     assert actual_filename == filename
     assert actual_hashes["length"] == len(data)
     assert (
         actual_hashes["checksums"]["sha1"] == "fdd1ce606a904b08c816ba84f3125f2af44d92b2"
     )  # noqa
     assert (
         actual_hashes["checksums"]["sha256"]
         == "1d9224378d77925d612c9f926eb9fb92850e6551def8328011b6a972323298d5"
     )
 
 
 @pytest.mark.fs
 def test_download_ok_with_hashes(tmp_path, requests_mock):
     """Download without issue should provide filename and hashes"""
     filename = "requests-0.0.1.tar.gz"
     url = "https://pypi.org/pypi/requests/%s" % filename
     data = "this is something"
     requests_mock.get(url, text=data, headers={"content-length": str(len(data))})
 
     # good hashes for such file
     good = {
         "sha1": "fdd1ce606a904b08c816ba84f3125f2af44d92b2",
         "sha256": "1d9224378d77925d612c9f926eb9fb92850e6551def8328011b6a972323298d5",  # noqa
     }
 
     actual_filepath, actual_hashes = download(url, dest=str(tmp_path), hashes=good)
 
     actual_filename = os.path.basename(actual_filepath)
     assert actual_filename == filename
     assert actual_hashes["length"] == len(data)
     assert actual_hashes["checksums"]["sha1"] == good["sha1"]
     assert actual_hashes["checksums"]["sha256"] == good["sha256"]
 
 
 @pytest.mark.fs
 def test_download_fail_hashes_mismatch(tmp_path, requests_mock):
     """Mismatch hash after download should raise
 
     """
     filename = "requests-0.0.1.tar.gz"
     url = "https://pypi.org/pypi/requests/%s" % filename
     data = "this is something"
     requests_mock.get(url, text=data, headers={"content-length": str(len(data))})
 
     # good hashes for such file
     good = {
         "sha1": "fdd1ce606a904b08c816ba84f3125f2af44d92b2",
         "sha256": "1d9224378d77925d612c9f926eb9fb92850e6551def8328011b6a972323298d5",  # noqa
     }
 
     for hash_algo in good.keys():
         wrong_hash = good[hash_algo].replace("1", "0")
         expected_hashes = good.copy()
         expected_hashes[hash_algo] = wrong_hash  # set the wrong hash
 
         expected_msg = "Failure when fetching %s. " "Checksum mismatched: %s != %s" % (
             url,
             wrong_hash,
             good[hash_algo],
         )
 
         with pytest.raises(ValueError, match=expected_msg):
             download(url, dest=str(tmp_path), hashes=expected_hashes)
 
 
 def test_api_info_failure(requests_mock):
     """Failure to fetch info/release information should raise"""
     url = "https://pypi.org/pypi/requests/json"
     status_code = 400
     requests_mock.get(url, status_code=status_code)
 
-    with pytest.raises(ValueError) as e0:
+    with pytest.raises(NotFound) as e0:
         api_info(url)
 
     assert e0.value.args[0] == "Fail to query '%s'. Reason: %s" % (url, status_code)
 
 
 def test_api_info(requests_mock):
     """Fetching json info from pypi project should be ok"""
     url = "https://pypi.org/pypi/requests/json"
     requests_mock.get(url, text='{"version": "0.0.1"}')
     actual_info = json.loads(api_info(url))
     assert actual_info == {
         "version": "0.0.1",
     }
 
 
 def test_release_name():
     for version, filename, expected_release in [
         ("0.0.1", None, "releases/0.0.1"),
         ("0.0.2", "something", "releases/0.0.2/something"),
     ]:
         assert release_name(version, filename) == expected_release
diff --git a/swh/loader/package/utils.py b/swh/loader/package/utils.py
index c3e7eb8..526e400 100644
--- a/swh/loader/package/utils.py
+++ b/swh/loader/package/utils.py
@@ -1,143 +1,144 @@
-# Copyright (C) 2019  The Software Heritage developers
+# Copyright (C) 2019-2021  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 copy
 import functools
 import logging
 import os
 from typing import Callable, Dict, Optional, Tuple, TypeVar
 
 import requests
 
+from swh.loader.exception import NotFound
 from swh.loader.package import DEFAULT_PARAMS
 from swh.model.hashutil import HASH_BLOCK_SIZE, MultiHash
 from swh.model.model import Person
 
 logger = logging.getLogger(__name__)
 
 
 DOWNLOAD_HASHES = set(["sha1", "sha256", "length"])
 
 
 EMPTY_AUTHOR = Person(fullname=b"", name=None, email=None,)
 
 
 def api_info(url: str, **extra_params) -> bytes:
     """Basic api client to retrieve information on project. This deals with
        fetching json metadata about pypi projects.
 
     Args:
         url (str): The api url (e.g PyPI, npm, etc...)
 
     Raises:
-        ValueError in case of query failures (for some reasons: 404, ...)
+        NotFound in case of query failures (for some reasons: 404, ...)
 
     Returns:
         The associated response's information
 
     """
     response = requests.get(url, **{**DEFAULT_PARAMS, **extra_params})
     if response.status_code != 200:
-        raise ValueError("Fail to query '%s'. Reason: %s" % (url, response.status_code))
+        raise NotFound(f"Fail to query '{url}'. Reason: {response.status_code}")
     return response.content
 
 
 def download(
     url: str,
     dest: str,
     hashes: Dict = {},
     filename: Optional[str] = None,
     auth: Optional[Tuple[str, str]] = None,
 ) -> Tuple[str, Dict]:
     """Download a remote tarball from url, uncompresses and computes swh hashes
        on it.
 
     Args:
         url: Artifact uri to fetch, uncompress and hash
         dest: Directory to write the archive to
         hashes: Dict of expected hashes (key is the hash algo) for the artifact
             to download (those hashes are expected to be hex string)
         auth: Optional tuple of login/password (for http authentication
             service, e.g. deposit)
 
     Raises:
         ValueError in case of any error when fetching/computing (length,
         checksums mismatched...)
 
     Returns:
         Tuple of local (filepath, hashes of filepath)
 
     """
     params = copy.deepcopy(DEFAULT_PARAMS)
     if auth is not None:
         params["auth"] = auth
     # so the connection does not hang indefinitely (read/connection timeout)
     timeout = params.get("timeout", 60)
     response = requests.get(url, **params, timeout=timeout, stream=True)
     if response.status_code != 200:
         raise ValueError("Fail to query '%s'. Reason: %s" % (url, response.status_code))
 
     filename = filename if filename else os.path.basename(url)
     logger.debug("filename: %s", filename)
     filepath = os.path.join(dest, filename)
     logger.debug("filepath: %s", filepath)
 
     h = MultiHash(hash_names=DOWNLOAD_HASHES)
     with open(filepath, "wb") as f:
         for chunk in response.iter_content(chunk_size=HASH_BLOCK_SIZE):
             h.update(chunk)
             f.write(chunk)
 
     # Also check the expected hashes if provided
     if hashes:
         actual_hashes = h.hexdigest()
         for algo_hash in hashes.keys():
             actual_digest = actual_hashes[algo_hash]
             expected_digest = hashes[algo_hash]
             if actual_digest != expected_digest:
                 raise ValueError(
                     "Failure when fetching %s. "
                     "Checksum mismatched: %s != %s"
                     % (url, expected_digest, actual_digest)
                 )
 
     computed_hashes = h.hexdigest()
     length = computed_hashes.pop("length")
     extrinsic_metadata = {
         "length": length,
         "filename": filename,
         "checksums": computed_hashes,
         "url": url,
     }
 
     logger.debug("extrinsic_metadata", extrinsic_metadata)
 
     return filepath, extrinsic_metadata
 
 
 def release_name(version: str, filename: Optional[str] = None) -> str:
     if filename:
         return "releases/%s/%s" % (version, filename)
     return "releases/%s" % version
 
 
 TReturn = TypeVar("TReturn")
 TSelf = TypeVar("TSelf")
 
 _UNDEFINED = object()
 
 
 def cached_method(f: Callable[[TSelf], TReturn]) -> Callable[[TSelf], TReturn]:
     cache_name = f"_cached_{f.__name__}"
 
     @functools.wraps(f)
     def newf(self):
         value = getattr(self, cache_name, _UNDEFINED)
         if value is _UNDEFINED:
             value = f(self)
             setattr(self, cache_name, value)
         return value
 
     return newf