diff --git a/swh/loader/package/cran/tests/test_cran.py b/swh/loader/package/cran/tests/test_cran.py
index 596afb0..cde9964 100644
--- a/swh/loader/package/cran/tests/test_cran.py
+++ b/swh/loader/package/cran/tests/test_cran.py
@@ -1,311 +1,362 @@
-# 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 datetime import datetime, timezone
 import os
 from os import path
+from unittest.mock import patch
 
 from dateutil.tz import tzlocal
 import pytest
 
 from swh.core.tarball import uncompress
 from swh.loader.package.cran.loader import (
     CRANLoader,
     extract_intrinsic_metadata,
     parse_date,
     parse_debian_control,
 )
 from swh.loader.tests import assert_last_visit_matches, check_snapshot, get_stats
 from swh.model.hashutil import hash_to_bytes
 from swh.model.model import Snapshot, SnapshotBranch, TargetType, TimestampWithTimezone
 
 SNAPSHOT = Snapshot(
     id=hash_to_bytes("920adcccc78aaeedd3cfa4459dd900d8c3431a21"),
     branches={
         b"HEAD": SnapshotBranch(
             target=b"releases/2.22-6", target_type=TargetType.ALIAS
         ),
         b"releases/2.22-6": SnapshotBranch(
             target=hash_to_bytes("42bdb16facd5140424359c8ce89a28ecfa1ce603"),
             target_type=TargetType.REVISION,
         ),
     },
 )
 
 
 def test_cran_parse_date():
     data = [
         # parsable, some have debatable results though
         ("2001-June-08", datetime(2001, 6, 8, 0, 0, tzinfo=timezone.utc)),
         (
             "Tue Dec 27 15:06:08 PST 2011",
             datetime(2011, 12, 27, 15, 6, 8, tzinfo=timezone.utc),
         ),
         ("8-14-2013", datetime(2013, 8, 14, 0, 0, tzinfo=timezone.utc)),
         ("2011-01", datetime(2011, 1, 1, 0, 0, tzinfo=timezone.utc)),
         ("201109", datetime(2009, 11, 20, 0, 0, tzinfo=timezone.utc)),
         ("04-12-2014", datetime(2014, 4, 12, 0, 0, tzinfo=timezone.utc)),
         (
             "2018-08-24, 10:40:10",
             datetime(2018, 8, 24, 10, 40, 10, tzinfo=timezone.utc),
         ),
         ("2013-October-16", datetime(2013, 10, 16, 0, 0, tzinfo=timezone.utc)),
         ("Aug 23, 2013", datetime(2013, 8, 23, 0, 0, tzinfo=timezone.utc)),
         ("27-11-2014", datetime(2014, 11, 27, 0, 0, tzinfo=timezone.utc)),
         ("2019-09-26,", datetime(2019, 9, 26, 0, 0, tzinfo=timezone.utc)),
         ("9/25/2014", datetime(2014, 9, 25, 0, 0, tzinfo=timezone.utc)),
         (
             "Fri Jun 27 17:23:53 2014",
             datetime(2014, 6, 27, 17, 23, 53, tzinfo=timezone.utc),
         ),
         ("28-04-2014", datetime(2014, 4, 28, 0, 0, tzinfo=timezone.utc)),
         ("04-14-2014", datetime(2014, 4, 14, 0, 0, tzinfo=timezone.utc)),
         (
             "2019-05-08 14:17:31 UTC",
             datetime(2019, 5, 8, 14, 17, 31, tzinfo=timezone.utc),
         ),
         (
             "Wed May 21 13:50:39 CEST 2014",
             datetime(2014, 5, 21, 13, 50, 39, tzinfo=tzlocal()),
         ),
         (
             "2018-04-10 00:01:04 KST",
             datetime(2018, 4, 10, 0, 1, 4, tzinfo=timezone.utc),
         ),
         ("2019-08-25 10:45", datetime(2019, 8, 25, 10, 45, tzinfo=timezone.utc)),
         ("March 9, 2015", datetime(2015, 3, 9, 0, 0, tzinfo=timezone.utc)),
         ("Aug. 18, 2012", datetime(2012, 8, 18, 0, 0, tzinfo=timezone.utc)),
         ("2014-Dec-17", datetime(2014, 12, 17, 0, 0, tzinfo=timezone.utc)),
         ("March 01, 2013", datetime(2013, 3, 1, 0, 0, tzinfo=timezone.utc)),
         ("2017-04-08.", datetime(2017, 4, 8, 0, 0, tzinfo=timezone.utc)),
         ("2014-Apr-22", datetime(2014, 4, 22, 0, 0, tzinfo=timezone.utc)),
         (
             "Mon Jan 12 19:54:04 2015",
             datetime(2015, 1, 12, 19, 54, 4, tzinfo=timezone.utc),
         ),
         ("May 22, 2014", datetime(2014, 5, 22, 0, 0, tzinfo=timezone.utc)),
         (
             "2014-08-12 09:55:10 EDT",
             datetime(2014, 8, 12, 9, 55, 10, tzinfo=timezone.utc),
         ),
         # unparsable
         ("Fabruary 21, 2012", None),
         ('2019-05-28"', None),
         ("2017-03-01 today", None),
         ("2016-11-0110.1093/icesjms/fsw182", None),
         ("2019-07-010", None),
         ("2015-02.23", None),
         ("20013-12-30", None),
         ("2016-08-017", None),
         ("2019-02-07l", None),
         ("2018-05-010", None),
         ("2019-09-27 KST", None),
         ("$Date$", None),
         ("2019-09-27 KST", None),
         ("2019-06-22 $Date$", None),
         ("$Date: 2013-01-18 12:49:03 -0600 (Fri, 18 Jan 2013) $", None),
         ("2015-7-013", None),
         ("2018-05-023", None),
         ("Check NEWS file for changes: news(package='simSummary')", None),
     ]
     for date, expected_date in data:
         actual_tstz = parse_date(date)
         if expected_date is None:
             assert actual_tstz is None, date
         else:
             expected_tstz = TimestampWithTimezone.from_datetime(expected_date)
             assert actual_tstz == expected_tstz, date
 
 
 @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)
     # sample url
     # https://cran.r-project.org/src_contrib_1.4.0_Recommended_KernSmooth_2.22-6.tar.gz  # noqa
     archive_path = path.join(
         datadir,
         "https_cran.r-project.org",
         "src_contrib_1.4.0_Recommended_KernSmooth_2.22-6.tar.gz",
     )
     uncompress(archive_path, dest=uncompressed_archive_path)
 
     actual_metadata = extract_intrinsic_metadata(uncompressed_archive_path)
 
     expected_metadata = {
         "Package": "KernSmooth",
         "Priority": "recommended",
         "Version": "2.22-6",
         "Date": "2001-June-08",
         "Title": "Functions for kernel smoothing for Wand & Jones (1995)",
         "Author": "S original by Matt Wand.\n\tR port by  Brian Ripley <ripley@stats.ox.ac.uk>.",  # noqa
         "Maintainer": "Brian Ripley <ripley@stats.ox.ac.uk>",
         "Description": 'functions for kernel smoothing (and density estimation)\n  corresponding to the book: \n  Wand, M.P. and Jones, M.C. (1995) "Kernel Smoothing".',  # noqa
         "License": "Unlimited use and distribution (see LICENCE).",
         "URL": "http://www.biostat.harvard.edu/~mwand",
     }
 
     assert actual_metadata == expected_metadata
 
 
 @pytest.mark.fs
 def test_extract_intrinsic_metadata_failures(tmp_path):
     """Parsing inexistent path/archive/PKG-INFO yield None"""
     # 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 = str(tmp_path / "something")
     os.mkdir(existing_path_no_pkginfo)
     assert extract_intrinsic_metadata(tmp_path) == {}
 
 
 def test_cran_one_visit(swh_config, requests_mock_datadir):
     version = "2.22-6"
     base_url = "https://cran.r-project.org"
     origin_url = f"{base_url}/Packages/Recommended_KernSmooth/index.html"
     artifact_url = (
         f"{base_url}/src_contrib_1.4.0_Recommended_KernSmooth_{version}.tar.gz"  # noqa
     )
     loader = CRANLoader(
         origin_url, artifacts=[{"url": artifact_url, "version": version,}]
     )
 
     actual_load_status = loader.load()
 
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": SNAPSHOT.id.hex(),
     }
 
     check_snapshot(SNAPSHOT, loader.storage)
 
     assert_last_visit_matches(loader.storage, origin_url, status="full", type="cran")
 
     visit_stats = get_stats(loader.storage)
     assert {
         "content": 33,
         "directory": 7,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 1,
         "skipped_content": 0,
         "snapshot": 1,
     } == visit_stats
 
     urls = [
         m.url
         for m in requests_mock_datadir.request_history
         if m.url.startswith(base_url)
     ]
     # visited each artifact once across 2 visits
     assert len(urls) == 1
 
 
 def test_cran_2_visits_same_origin(swh_config, requests_mock_datadir):
     """Multiple visits on the same origin, only 1 archive fetch"""
     version = "2.22-6"
     base_url = "https://cran.r-project.org"
     origin_url = f"{base_url}/Packages/Recommended_KernSmooth/index.html"
     artifact_url = (
         f"{base_url}/src_contrib_1.4.0_Recommended_KernSmooth_{version}.tar.gz"  # noqa
     )
     loader = CRANLoader(
         origin_url, artifacts=[{"url": artifact_url, "version": version}]
     )
 
     # first visit
     actual_load_status = loader.load()
 
     expected_snapshot_id = "920adcccc78aaeedd3cfa4459dd900d8c3431a21"
     assert actual_load_status == {
         "status": "eventful",
         "snapshot_id": SNAPSHOT.id.hex(),
     }
 
     check_snapshot(SNAPSHOT, loader.storage)
 
     assert_last_visit_matches(loader.storage, origin_url, status="full", type="cran")
 
     visit_stats = get_stats(loader.storage)
     assert {
         "content": 33,
         "directory": 7,
         "origin": 1,
         "origin_visit": 1,
         "release": 0,
         "revision": 1,
         "skipped_content": 0,
         "snapshot": 1,
     } == visit_stats
 
     # second visit
     actual_load_status2 = loader.load()
 
     assert actual_load_status2 == {
         "status": "uneventful",
         "snapshot_id": expected_snapshot_id,
     }
 
     assert_last_visit_matches(loader.storage, origin_url, status="full", type="cran")
 
     visit_stats2 = get_stats(loader.storage)
     visit_stats["origin_visit"] += 1
     assert visit_stats2 == visit_stats, "same stats as 1st visit, +1 visit"
 
     urls = [
         m.url
         for m in requests_mock_datadir.request_history
         if m.url.startswith(base_url)
     ]
     assert len(urls) == 1, "visited one time artifact url (across 2 visits)"
 
 
 def test_parse_debian_control(datadir):
     description_file = os.path.join(datadir, "description", "acepack")
 
     actual_metadata = parse_debian_control(description_file)
 
     assert actual_metadata == {
         "Package": "acepack",
         "Maintainer": "Shawn Garbett",
         "Version": "1.4.1",
         "Author": "Phil Spector, Jerome Friedman, Robert Tibshirani...",
         "Description": "Two nonparametric methods for multiple regression...",
         "Title": "ACE & AVAS 4 Selecting Multiple Regression Transformations",
         "License": "MIT + file LICENSE",
         "Suggests": "testthat",
         "Packaged": "2016-10-28 15:38:59 UTC; garbetsp",
         "Repository": "CRAN",
         "Date/Publication": "2016-10-29 00:11:52",
         "NeedsCompilation": "yes",
     }
 
 
 def test_parse_debian_control_unicode_issue(datadir):
     # iso-8859-1 caused failure, now fixed
     description_file = os.path.join(datadir, "description", "KnownBR")
 
     actual_metadata = parse_debian_control(description_file)
 
     assert actual_metadata == {
         "Package": "KnowBR",
         "Version": "2.0",
         "Title": """Discriminating Well Surveyed Spatial Units from Exhaustive
         Biodiversity Databases""",
         "Author": "Cástor Guisande González and Jorge M. Lobo",
         "Maintainer": "Cástor Guisande González <castor@email.es>",
         "Description": "It uses species accumulation curves and diverse estimators...",
         "License": "GPL (>= 2)",
         "Encoding": "latin1",
         "Depends": "R (>= 3.0), fossil, mgcv, plotrix, sp, vegan",
         "Suggests": "raster, rgbif",
         "NeedsCompilation": "no",
         "Packaged": "2019-01-30 13:27:29 UTC; castor",
         "Repository": "CRAN",
         "Date/Publication": "2019-01-31 20:53:50 UTC",
     }
+
+
+@pytest.mark.parametrize(
+    "method_name",
+    ["build_extrinsic_snapshot_metadata", "build_extrinsic_origin_metadata",],
+)
+def test_cran_fail_to_build_or_load_extrinsic_metadata(
+    method_name, swh_config, requests_mock_datadir
+):
+    """problem during loading: {visit: failed, status: failed, no snapshot}
+
+    """
+    version = "2.22-6"
+    base_url = "https://cran.r-project.org"
+    origin_url = f"{base_url}/Packages/Recommended_KernSmooth/index.html"
+    artifact_url = (
+        f"{base_url}/src_contrib_1.4.0_Recommended_KernSmooth_{version}.tar.gz"  # noqa
+    )
+
+    full_method_name = f"swh.loader.package.cran.loader.CRANLoader.{method_name}"
+    with patch(
+        full_method_name,
+        side_effect=ValueError("Fake to fail to build or load extrinsic metadata"),
+    ):
+        loader = CRANLoader(
+            origin_url, artifacts=[{"url": artifact_url, "version": version}]
+        )
+
+        actual_load_status = loader.load()
+
+        assert actual_load_status == {
+            "status": "failed",
+            "snapshot_id": SNAPSHOT.id.hex(),
+        }
+
+        visit_stats = get_stats(loader.storage)
+        assert {
+            "content": 33,
+            "directory": 7,
+            "origin": 1,
+            "origin_visit": 1,
+            "release": 0,
+            "revision": 1,
+            "skipped_content": 0,
+            "snapshot": 1,
+        } == visit_stats
+
+        assert_last_visit_matches(
+            loader.storage, origin_url, status="partial", type="cran"
+        )
diff --git a/swh/loader/package/loader.py b/swh/loader/package/loader.py
index ca39ba7..b81e1bd 100644
--- a/swh/loader/package/loader.py
+++ b/swh/loader/package/loader.py
@@ -1,803 +1,803 @@
-# 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 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.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.
 
         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"  # either: partial, full
+        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 = "partial"
+            status_visit = "failed"
             status_load = "failed"
             return finalize_visit()
 
         load_exceptions: List[Exception] = []
 
         for version in self.get_versions():  # for each
             logger.debug("version: %s", version)
             tmp_revisions[version] = []
             # `p_` stands for `package_`
             for branch_name, p_info in self.get_package_info(version):
                 logger.debug("package_info: %s", p_info)
                 revision_id = self.resolve_revision_from(known_artifacts, p_info)
                 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 = "partial"
+            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 = "partial"
+            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/npm/tests/test_npm.py b/swh/loader/package/npm/tests/test_npm.py
index c7c69bb..e35ad70 100644
--- a/swh/loader/package/npm/tests/test_npm.py
+++ b/swh/loader/package/npm/tests/test_npm.py
@@ -1,703 +1,703 @@
-# 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.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="partial", type="npm")
+    assert_last_visit_matches(loader.storage, url, status="failed", type="npm")
diff --git a/swh/loader/package/pypi/tests/test_pypi.py b/swh/loader/package/pypi/tests/test_pypi.py
index 235d2c2..e0fe6cc 100644
--- a/swh/loader/package/pypi/tests/test_pypi.py
+++ b/swh/loader/package/pypi/tests/test_pypi.py
@@ -1,876 +1,906 @@
-# 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 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="partial", type="pypi")
+        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
     )