diff --git a/swh/loader/package/debian.py b/swh/loader/package/debian.py
index d89cc05..fb459df 100644
--- a/swh/loader/package/debian.py
+++ b/swh/loader/package/debian.py
@@ -1,394 +1,394 @@
 # Copyright (C) 2017-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import email.utils
 import iso8601
 import logging
 import re
 import subprocess
 
 from dateutil.parser import parse as parse_date
 from debian.changelog import Changelog
 from debian.deb822 import Dsc
 from os import path
 from typing import (
     Any, Dict, Generator, List, Mapping, Optional, Sequence, Tuple
 )
 
 from swh.loader.package.loader import PackageLoader
 from swh.loader.package.utils import download, release_name
 
 
 logger = logging.getLogger(__name__)
 UPLOADERS_SPLIT = re.compile(r'(?<=\>)\s*,\s*')
 
 
 class DebianLoader(PackageLoader):
     """Load debian origins into swh archive.
 
     """
     visit_type = 'deb'
 
     def __init__(self, url: str, date: str, packages: Mapping[str, Any]):
         """Debian Loader implementation.
 
         Args:
             url: Origin url (e.g. deb://Debian/packages/cicero)
             date: Ignored
             packages: versioned packages and associated artifacts, example::
 
               {
                 'stretch/contrib/0.7.2-3': {
                   'name': 'cicero',
                   'version': '0.7.2-3'
                   'files': {
                     'cicero_0.7.2-3.diff.gz': {
                        'md5sum': 'a93661b6a48db48d59ba7d26796fc9ce',
                        'name': 'cicero_0.7.2-3.diff.gz',
                        'sha256': 'f039c9642fe15c75bed5254315e2a29f...',
                        'size': 3964,
                        'uri': 'http://d.d.o/cicero_0.7.2-3.diff.gz',
                     },
                     'cicero_0.7.2-3.dsc': {
                       'md5sum': 'd5dac83eb9cfc9bb52a15eb618b4670a',
                       'name': 'cicero_0.7.2-3.dsc',
                       'sha256': '35b7f1048010c67adfd8d70e4961aefb...',
                       'size': 1864,
                       'uri': 'http://d.d.o/cicero_0.7.2-3.dsc',
                     },
                     'cicero_0.7.2.orig.tar.gz': {
                       'md5sum': '4353dede07c5728319ba7f5595a7230a',
                       'name': 'cicero_0.7.2.orig.tar.gz',
                       'sha256': '63f40f2436ea9f67b44e2d4bd669dbab...',
                       'size': 96527,
                       'uri': 'http://d.d.o/cicero_0.7.2.orig.tar.gz',
                     }
                   },
                 },
                 # ...
               }
 
         """
         super().__init__(url=url)
         self.packages = packages
 
     def get_versions(self) -> Sequence[str]:
         """Returns the keys of the packages input (e.g.
            stretch/contrib/0.7.2-3, etc...)
 
         """
         return list(self.packages.keys())
 
     def get_package_info(self, version: str) -> Generator[
             Tuple[str, Mapping[str, Any]], None, None]:
         meta = self.packages[version]
         p_info = meta.copy()
         p_info['raw'] = meta
         yield release_name(version), p_info
 
     def resolve_revision_from(
             self, known_package_artifacts: Dict, artifact_metadata: Dict) \
             -> Optional[bytes]:
         artifacts_to_fetch = artifact_metadata['files']
         logger.debug('k_p_artifacts: %s', known_package_artifacts)
         logger.debug('artifacts_to_fetch: %s', artifacts_to_fetch)
         for rev_id, known_artifacts in known_package_artifacts.items():
             logger.debug('Revision: %s', rev_id)
             logger.debug('Associated known_artifacts: %s', known_artifacts)
             known_artifacts = known_artifacts['extrinsic']['raw']['files']
             rev_found = True
             for a_name, k_artifact in known_artifacts.items():
                 artifact_to_fetch = artifacts_to_fetch.get(a_name)
                 logger.debug('artifact_to_fetch: %s', artifact_to_fetch)
                 if artifact_to_fetch is None:
                     # as soon as we do not see an artifact, we consider we need
                     # to check the other revision
                     rev_found = False
                 if k_artifact['sha256'] != artifact_to_fetch['sha256']:
                     # Hash is different, we consider we need to check the other
                     # revisions
                     rev_found = False
             if rev_found:
                 logger.debug('Existing revision %s found for new artifacts.',
                              rev_id)
                 return rev_id
         logger.debug('No existing revision found for the new artifacts.')
         return None
 
     def download_package(self, p_info: Mapping[str, Any],
                          tmpdir: str) -> List[Tuple[str, Mapping]]:
         """Contrary to other package loaders (1 package, 1 artifact),
         `a_metadata` represents the package's datafiles set to fetch:
         - <package-version>.orig.tar.gz
         - <package-version>.dsc
         - <package-version>.diff.gz
 
         This is delegated to the `download_package` function.
 
         """
         all_hashes = download_package(p_info, tmpdir)
         logger.debug('all_hashes: %s', all_hashes)
         res = []
         for hashes in all_hashes.values():
             res.append((tmpdir, hashes))
             logger.debug('res: %s', res)
         return res
 
     def uncompress(self, dl_artifacts: List[Tuple[str, Mapping[str, Any]]],
                    dest: str) -> str:
         logger.debug('dl_artifacts: %s', dl_artifacts)
         return extract_package(dl_artifacts, dest=dest)
 
     def build_revision(self, a_metadata: Mapping[str, Any],
                        uncompressed_path: str) -> Dict:
         dsc_url, dsc_name = dsc_information(a_metadata)
         if not dsc_name:
             raise ValueError(
                 'dsc name for url %s should not be None' % dsc_url)
         dsc_path = path.join(path.dirname(uncompressed_path), dsc_name)
         i_metadata = get_package_metadata(
             a_metadata, dsc_path, uncompressed_path)
 
         logger.debug('i_metadata: %s', i_metadata)
         logger.debug('a_metadata: %s', a_metadata)
 
         msg = 'Synthetic revision for Debian source package %s version %s' % (
             a_metadata['name'], a_metadata['version'])
 
         date = iso8601.parse_date(i_metadata['changelog']['date'])
         author = prepare_person(i_metadata['changelog']['person'])
 
         # inspired from swh.loader.debian.converters.package_metadata_to_revision  # noqa
         return {
             'type': 'dsc',
             'message': msg.encode('utf-8'),
             'author': author,
             'date': date,
             'committer': author,
             'committer_date': date,
             'parents': [],
             'metadata': {
                 'intrinsic': {
                     'tool': 'dsc',
                     'raw': i_metadata,
                 },
                 'extrinsic': {
                     'provider': dsc_url,
                     'when': self.visit_date.isoformat(),
                     'raw': a_metadata,
                 },
             }
         }
 
 
 def uid_to_person(uid: str) -> Mapping[str, str]:
     """Convert an uid to a person suitable for insertion.
 
     Args:
         uid: an uid of the form "Name <email@ddress>"
 
     Returns:
         a dictionary with the following keys:
 
         - name: the name associated to the uid
         - email: the mail associated to the uid
         - fullname: the actual uid input
 
     """
     logger.debug('uid: %s', uid)
     ret = {
         'name': '',
         'email': '',
         'fullname': uid,
     }
 
     name, mail = email.utils.parseaddr(uid)
     if name and email:
         ret['name'] = name
         ret['email'] = mail
     else:
         ret['name'] = uid
     return ret
 
 
 def prepare_person(person: Mapping[str, str]) -> Mapping[str, bytes]:
     """Prepare person for swh serialization...
 
     Args:
         A person dict
 
     Returns:
         A person dict ready for storage
 
     """
     ret = {}
     for key, value in person.items():
         ret[key] = value.encode('utf-8')
     return ret
 
 
 def download_package(
         package: Mapping[str, Any], tmpdir: Any) -> Mapping[str, Any]:
     """Fetch a source package in a temporary directory and check the checksums
     for all files.
 
     Args:
         package: Dict defining the set of files representing a debian package
         tmpdir: Where to download and extract the files to ingest
 
     Returns:
         Dict of swh hashes per filename key
 
     """
     all_hashes = {}
     for filename, fileinfo in package['files'].items():
         uri = fileinfo['uri']
         logger.debug('fileinfo: %s', fileinfo)
         extrinsic_hashes = {'sha256': fileinfo['sha256']}
         logger.debug('extrinsic_hashes(%s): %s', filename, extrinsic_hashes)
         filepath, hashes = download(uri, dest=tmpdir, filename=filename,
                                     hashes=extrinsic_hashes)
         all_hashes[filename] = hashes
 
     logger.debug('all_hashes: %s', all_hashes)
     return all_hashes
 
 
 def dsc_information(package: Mapping[str, Any]) -> Tuple[
         Optional[str], Optional[str]]:
     """Retrieve dsc information from a package.
 
     Args:
         package: Package metadata information
 
     Returns:
         Tuple of dsc file's uri, dsc's full disk path
 
     """
     dsc_name = None
     dsc_url = None
     for filename, fileinfo in package['files'].items():
         if filename.endswith('.dsc'):
             if dsc_name:
                 raise ValueError(
-                    'Package %s_%s references several dsc files' %
+                    'Package %s_%s references several dsc files.' %
                     (package['name'], package['version'])
                 )
             dsc_url = fileinfo['uri']
             dsc_name = filename
 
     return dsc_url, dsc_name
 
 
 def extract_package(dl_artifacts: List[Tuple[str, Mapping]], dest: str) -> str:
     """Extract a Debian source package to a given directory.
 
     Note that after extraction the target directory will be the root of the
     extracted package, rather than containing it.
 
     Args:
         package: package information dictionary
         dest: directory where the package files are stored
 
     Returns:
         Package extraction directory
 
     """
     a_path = dl_artifacts[0][0]
     logger.debug('dl_artifacts: %s', dl_artifacts)
     for _, hashes in dl_artifacts:
         logger.debug('hashes: %s', hashes)
         filename = hashes['filename']
         if filename.endswith('.dsc'):
             dsc_name = filename
             break
 
     dsc_path = path.join(a_path, dsc_name)
     destdir = path.join(dest, 'extracted')
     logfile = path.join(dest, 'extract.log')
     logger.debug('extract Debian source package %s in %s' %
                  (dsc_path, destdir), extra={
                      'swh_type': 'deb_extract',
                      'swh_dsc': dsc_path,
                      'swh_destdir': destdir,
                  })
 
     cmd = ['dpkg-source',
            '--no-copy', '--no-check',
            '--ignore-bad-version',
            '-x', dsc_path,
            destdir]
 
     try:
         with open(logfile, 'w') as stdout:
             subprocess.check_call(cmd, stdout=stdout, stderr=subprocess.STDOUT)
     except subprocess.CalledProcessError as e:
         logdata = open(logfile, 'r').read()
         raise ValueError('dpkg-source exited with code %s: %s' %
                          (e.returncode, logdata)) from None
 
     return destdir
 
 
 def get_package_metadata(package: Mapping[str, Any], dsc_path: str,
                          extracted_path: str) -> Mapping[str, Any]:
     """Get the package metadata from the source package at dsc_path,
     extracted in extracted_path.
 
     Args:
         package: the package dict (with a dsc_path key)
         dsc_path: path to the package's dsc file
         extracted_path: the path where the package got extracted
 
     Returns:
         dict: a dictionary with the following keys:
 
         - history: list of (package_name, package_version) tuples parsed from
           the package changelog
 
     """
     with open(dsc_path, 'rb') as dsc:
         parsed_dsc = Dsc(dsc)
 
     # Parse the changelog to retrieve the rest of the package information
     changelog_path = path.join(extracted_path, 'debian/changelog')
     with open(changelog_path, 'rb') as changelog:
         try:
             parsed_changelog = Changelog(changelog)
         except UnicodeDecodeError:
             logger.warning('Unknown encoding for changelog %s,'
                            ' falling back to iso' %
                            changelog_path, extra={
                                'swh_type': 'deb_changelog_encoding',
                                'swh_name': package['name'],
                                'swh_version': str(package['version']),
                                'swh_changelog': changelog_path,
                            })
 
             # need to reset as Changelog scrolls to the end of the file
             changelog.seek(0)
             parsed_changelog = Changelog(changelog, encoding='iso-8859-15')
 
     package_info = {
         'name': package['name'],
         'version': str(package['version']),
         'changelog': {
             'person': uid_to_person(parsed_changelog.author),
             'date': parse_date(parsed_changelog.date).isoformat(),
             'history': [(block.package, str(block.version))
                         for block in parsed_changelog][1:],
         }
     }
 
     maintainers = [
         uid_to_person(parsed_dsc['Maintainer']),
     ]
     maintainers.extend(
         uid_to_person(person)
         for person in UPLOADERS_SPLIT.split(parsed_dsc.get('Uploaders', ''))
     )
     package_info['maintainers'] = maintainers
 
     return package_info
diff --git a/swh/loader/package/tests/test_pypi.py b/swh/loader/package/tests/test_pypi.py
index 0358af5..27f2953 100644
--- a/swh/loader/package/tests/test_pypi.py
+++ b/swh/loader/package/tests/test_pypi.py
@@ -1,701 +1,701 @@
 # Copyright (C) 2019 The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import os
 
 from os import path
 
 import pytest
 
 from unittest.mock import patch
 
 from swh.core.tarball import uncompress
 from swh.core.pytest_plugin import requests_mock_datadir_factory
 from swh.model.hashutil import hash_to_bytes
 
 from swh.loader.package.pypi import (
     PyPILoader, pypi_api_url, author, extract_intrinsic_metadata
 )
 from swh.loader.package.tests.common import (
     check_snapshot, check_metadata_paths, get_stats
 )
 
 
 def test_author_basic():
     data = {
         'author': "i-am-groot",
         'author_email': 'iam@groot.org',
     }
     actual_author = author(data)
 
     expected_author = {
         '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 = {
         '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 = {
         '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 = {
         '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 = {
         '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 = {
         'fullname': b'[marie, jeanne, pierre] <[marie@somewhere.org, jeanne@somewhere.org]>',  # noqa
         'name': b'[marie, jeanne, pierre]',
         'email': b'[marie@somewhere.org, jeanne@somewhere.org]',
     }
 
     actual_author == expected_author
 
 
 # configuration error #
 
 def test_badly_configured_loader_raise(monkeypatch):
     """Badly configured loader should raise"""
     monkeypatch.delenv('SWH_CONFIG_FILENAME', raising=False)
     with pytest.raises(ValueError) as e:
         PyPILoader(url='some-url')
 
     assert 'Misconfiguration' in e.value.args[0]
 
 
 def test_pypi_api_url():
     """Compute pypi api url from the pypi project url should be ok"""
     url = pypi_api_url('https://pypi.org/project/requests')
     assert url == 'https://pypi.org/pypi/requests/json'
 
 
 @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 inexistant path/archive/PKG-INFO yield None"""
+    """Parsing inexistent path/archive/PKG-INFO yield None"""
     tmp_path = str(tmp_path)  # py3.5 work around (PosixPath issue)
-    # inexistant first level path
-    assert extract_intrinsic_metadata('/something-inexistant') == {}
-    # inexistant second level path (as expected by pypi archives)
+    # 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) == {}
-    # inexistant PKG-INFO within second level path
+    # inexistent PKG-INFO within second level path
     existing_path_no_pkginfo = path.join(tmp_path, 'something')
     os.mkdir(existing_path_no_pkginfo)
     assert extract_intrinsic_metadata(tmp_path) == {}
 
 
 # LOADER SCENARIO #
 
 # "edge" cases (for the same origin) #
 
 
 # no release artifact:
 # {visit full, status: uneventful, no contents, etc...}
 requests_mock_datadir_missing_all = requests_mock_datadir_factory(ignore_urls=[
     'https://files.pythonhosted.org/packages/ec/65/c0116953c9a3f47de89e71964d6c7b0c783b01f29fa3390584dbf3046b4d/0805nexter-1.1.0.zip',  # noqa
     'https://files.pythonhosted.org/packages/c4/a0/4562cda161dc4ecbbe9e2a11eb365400c0461845c5be70d73869786809c4/0805nexter-1.2.0.zip',  # noqa
 ])
 
 
 def test_no_release_artifact(swh_config, requests_mock_datadir_missing_all):
     """Load a pypi project with all artifacts missing ends up with no snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'uneventful'
     assert actual_load_status['snapshot_id'] is not None
 
     stats = get_stats(loader.storage)
     assert {
         'content': 0,
         'directory': 0,
         'origin': 1,
         'origin_visit': 1,
         'person': 0,
         'release': 0,
         'revision': 0,
         'skipped_content': 0,
         'snapshot': 1,
     } == stats
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'partial'
     assert origin_visit['type'] == 'pypi'
 
 
 # problem during loading:
 # {visit: partial, status: uneventful, no snapshot}
 
 
 def test_release_with_traceback(swh_config):
     url = 'https://pypi.org/project/0805nexter'
     with patch('swh.loader.package.pypi.PyPILoader.get_default_version',
                side_effect=ValueError('Problem')):
         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,
             'person': 0,
             'release': 0,
             'revision': 0,
             'skipped_content': 0,
             'snapshot': 0,
         } == stats
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'partial'
     assert origin_visit['type'] == 'pypi'
 
 
 # problem during loading: failure early enough in between swh contents...
 # some contents (contents, directories, etc...) have been written in storage
 # {visit: partial, status: eventful, no snapshot}
 
 # problem during loading: failure late enough we can have snapshots (some
 # revisions are written in storage already)
 # {visit: partial, status: eventful, snapshot}
 
 # "normal" cases (for the same origin) #
 
 
 requests_mock_datadir_missing_one = requests_mock_datadir_factory(ignore_urls=[
     'https://files.pythonhosted.org/packages/ec/65/c0116953c9a3f47de89e71964d6c7b0c783b01f29fa3390584dbf3046b4d/0805nexter-1.1.0.zip',  # noqa
 ])
 
 # some missing release artifacts:
 # {visit partial, status: eventful, 1 snapshot}
 
 
 def test_revision_metadata_structure(swh_config, requests_mock_datadir):
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     assert actual_load_status['status'] == 'eventful'
     assert actual_load_status['snapshot_id'] is not None
 
     expected_revision_id = hash_to_bytes(
         'e445da4da22b31bfebb6ffc4383dbf839a074d21')
     revision = list(loader.storage.revision_get([expected_revision_id]))[0]
 
     assert revision is not None
 
     check_metadata_paths(revision['metadata'], paths=[
         ('intrinsic.tool', str),
         ('intrinsic.raw', dict),
         ('extrinsic.provider', str),
         ('extrinsic.when', str),
         ('extrinsic.raw', dict),
         ('original_artifact', list),
     ])
 
     for original_artifact in revision['metadata']['original_artifact']:
         check_metadata_paths(original_artifact, paths=[
             ('filename', str),
             ('length', int),
             ('checksums', dict),
         ])
 
 
 def test_visit_with_missing_artifact(
         swh_config, requests_mock_datadir_missing_one):
     """Load a pypi project with some missing artifacts ends up with 1 snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = 'dd0e4201a232b1c104433741dbf45895b8ac9355'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id
     }
 
     stats = get_stats(loader.storage)
 
     assert {
         'content': 3,
         'directory': 2,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 1,
         'skipped_content': 0,
         'snapshot': 1
     } == stats
 
     expected_contents = map(hash_to_bytes, [
         '405859113963cb7a797642b45f171d6360425d16',
         'e5686aa568fdb1d19d7f1329267082fe40482d31',
         '83ecf6ec1114fd260ca7a833a2d165e71258c338',
     ])
 
     assert list(loader.storage.content_missing_per_sha1(expected_contents))\
         == []
 
     expected_dirs = map(hash_to_bytes, [
         'b178b66bd22383d5f16f4f5c923d39ca798861b4',
         'c3a58f8b57433a4b56caaa5033ae2e0931405338',
     ])
 
     assert list(loader.storage.directory_missing(expected_dirs)) == []
 
     # {revision hash: directory hash}
     expected_revs = {
         hash_to_bytes('e445da4da22b31bfebb6ffc4383dbf839a074d21'): hash_to_bytes('b178b66bd22383d5f16f4f5c923d39ca798861b4'),  # noqa
     }
     assert list(loader.storage.revision_missing(expected_revs)) == []
 
     expected_branches = {
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.2.0',
             'target_type': 'alias',
         },
     }
 
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, storage=loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'partial'
     assert origin_visit['type'] == 'pypi'
 
 
 def test_visit_with_1_release_artifact(swh_config, requests_mock_datadir):
     """With no prior visit, load a pypi project ends up with 1 snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = 'ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id
     }
 
     stats = get_stats(loader.storage)
     assert {
         'content': 6,
         'directory': 4,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 2,
         'skipped_content': 0,
         'snapshot': 1
     } == stats
 
     expected_contents = map(hash_to_bytes, [
         'a61e24cdfdab3bb7817f6be85d37a3e666b34566',
         '938c33483285fd8ad57f15497f538320df82aeb8',
         'a27576d60e08c94a05006d2e6d540c0fdb5f38c8',
         '405859113963cb7a797642b45f171d6360425d16',
         'e5686aa568fdb1d19d7f1329267082fe40482d31',
         '83ecf6ec1114fd260ca7a833a2d165e71258c338',
     ])
 
     assert list(loader.storage.content_missing_per_sha1(expected_contents))\
         == []
 
     expected_dirs = map(hash_to_bytes, [
         '05219ba38bc542d4345d5638af1ed56c7d43ca7d',
         'cf019eb456cf6f78d8c4674596f1c9a97ece8f44',
         'b178b66bd22383d5f16f4f5c923d39ca798861b4',
         'c3a58f8b57433a4b56caaa5033ae2e0931405338',
     ])
 
     assert list(loader.storage.directory_missing(expected_dirs)) == []
 
     # {revision hash: directory hash}
     expected_revs = {
         hash_to_bytes('4c99891f93b81450385777235a37b5e966dd1571'): hash_to_bytes('05219ba38bc542d4345d5638af1ed56c7d43ca7d'),  # noqa
         hash_to_bytes('e445da4da22b31bfebb6ffc4383dbf839a074d21'): hash_to_bytes('b178b66bd22383d5f16f4f5c923d39ca798861b4'),  # noqa
     }
     assert list(loader.storage.revision_missing(expected_revs)) == []
 
     expected_branches = {
         'releases/1.1.0': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.2.0',
             'target_type': 'alias',
         },
     }
 
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'
 
 
 def test_multiple_visits_with_no_change(swh_config, requests_mock_datadir):
     """Multiple visits with no changes results in 1 same snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     snapshot_id = 'ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': snapshot_id,
     }
 
     stats = get_stats(loader.storage)
 
     assert {
         'content': 6,
         'directory': 4,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 2,
         'skipped_content': 0,
         'snapshot': 1
     } == stats
 
     expected_branches = {
         'releases/1.1.0': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.2.0',
             'target_type': 'alias',
         },
     }
 
     expected_snapshot = {
         'id': snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'
 
     actual_load_status2 = loader.load()
     assert actual_load_status2 == {
         'status': 'uneventful',
         'snapshot_id': actual_load_status2['snapshot_id']
     }
 
     stats2 = get_stats(loader.storage)
     expected_stats2 = stats.copy()
     expected_stats2['origin_visit'] = 1 + 1
     assert expected_stats2 == stats2
 
     # same snapshot
     actual_snapshot_id = origin_visit['snapshot']
     assert actual_snapshot_id == hash_to_bytes(snapshot_id)
 
 
 def test_incremental_visit(swh_config, requests_mock_datadir_visits):
     """With prior visit, 2nd load will result with a different snapshot
 
     """
     url = 'https://pypi.org/project/0805nexter'
     loader = PyPILoader(url)
 
     visit1_actual_load_status = loader.load()
     visit1_stats = get_stats(loader.storage)
     expected_snapshot_id = 'ba6e158ada75d0b3cfb209ffdf6daa4ed34a227a'
     assert visit1_actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id
     }
 
     origin_visit1 = next(loader.storage.origin_visit_get(url))
     assert origin_visit1['status'] == 'full'
     assert origin_visit1['type'] == 'pypi'
 
     assert {
         'content': 6,
         'directory': 4,
         'origin': 1,
         'origin_visit': 1,
         'person': 1,
         'release': 0,
         'revision': 2,
         'skipped_content': 0,
         'snapshot': 1
     } == visit1_stats
 
     # Reset internal state
     loader._info = None
 
     visit2_actual_load_status = loader.load()
     visit2_stats = get_stats(loader.storage)
 
     assert visit2_actual_load_status['status'] == 'eventful'
     expected_snapshot_id2 = '2e5149a7b0725d18231a37b342e9b7c4e121f283'
     assert visit2_actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id2
     }
 
     visits = list(loader.storage.origin_visit_get(url))
     assert len(visits) == 2
     assert visits[1]['status'] == 'full'
     assert visits[1]['type'] == 'pypi'
 
     assert {
         'content': 6 + 1,     # 1 more content
         'directory': 4 + 2,   # 2 more directories
         'origin': 1,
         'origin_visit': 1 + 1,
         'person': 1,
         'release': 0,
         'revision': 2 + 1,    # 1 more revision
         'skipped_content': 0,
         'snapshot': 1 + 1,    # 1 more snapshot
     } == visit2_stats
 
     expected_contents = map(hash_to_bytes, [
         'a61e24cdfdab3bb7817f6be85d37a3e666b34566',
         '938c33483285fd8ad57f15497f538320df82aeb8',
         'a27576d60e08c94a05006d2e6d540c0fdb5f38c8',
         '405859113963cb7a797642b45f171d6360425d16',
         'e5686aa568fdb1d19d7f1329267082fe40482d31',
         '83ecf6ec1114fd260ca7a833a2d165e71258c338',
         '92689fa2b7fb4d4fc6fb195bf73a50c87c030639'
     ])
 
     assert list(loader.storage.content_missing_per_sha1(expected_contents))\
         == []
 
     expected_dirs = map(hash_to_bytes, [
         '05219ba38bc542d4345d5638af1ed56c7d43ca7d',
         'cf019eb456cf6f78d8c4674596f1c9a97ece8f44',
         'b178b66bd22383d5f16f4f5c923d39ca798861b4',
         'c3a58f8b57433a4b56caaa5033ae2e0931405338',
         'e226e7e4ad03b4fc1403d69a18ebdd6f2edd2b3a',
         '52604d46843b898f5a43208045d09fcf8731631b',
 
     ])
 
     assert list(loader.storage.directory_missing(expected_dirs)) == []
 
     # {revision hash: directory hash}
     expected_revs = {
         hash_to_bytes('4c99891f93b81450385777235a37b5e966dd1571'): hash_to_bytes('05219ba38bc542d4345d5638af1ed56c7d43ca7d'),  # noqa
         hash_to_bytes('e445da4da22b31bfebb6ffc4383dbf839a074d21'): hash_to_bytes('b178b66bd22383d5f16f4f5c923d39ca798861b4'),  # noqa
         hash_to_bytes('51247143b01445c9348afa9edfae31bf7c5d86b1'): hash_to_bytes('e226e7e4ad03b4fc1403d69a18ebdd6f2edd2b3a'),  # noqa
     }
 
     assert list(loader.storage.revision_missing(expected_revs)) == []
 
     expected_branches = {
         'releases/1.1.0': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.2.0': {
             'target': 'e445da4da22b31bfebb6ffc4383dbf839a074d21',
             'target_type': 'revision',
         },
         'releases/1.3.0': {
             'target': '51247143b01445c9348afa9edfae31bf7c5d86b1',
             'target_type': 'revision',
         },
         'HEAD': {
             'target': 'releases/1.3.0',
             'target_type': 'alias',
         },
     }
     expected_snapshot = {
         'id': expected_snapshot_id2,
         'branches': expected_branches,
     }
 
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = list(loader.storage.origin_visit_get(url))[-1]
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'
 
     urls = [
         m.url for m in requests_mock_datadir_visits.request_history
         if m.url.startswith('https://files.pythonhosted.org')
     ]
     # visited each artifact once across 2 visits
     assert len(urls) == len(set(urls))
 
 
 # release artifact, no new artifact
 # {visit full, status uneventful, same snapshot as before}
 
 # release artifact, old artifact with different checksums
 # {visit full, status full, new snapshot with shared history and some new
 # different history}
 
 # release with multiple sdist artifacts per pypi "version"
 # snapshot branch output is different
 
 def test_visit_1_release_with_2_artifacts(swh_config, requests_mock_datadir):
     """With no prior visit, load a pypi project ends up with 1 snapshot
 
     """
     url = 'https://pypi.org/project/nexter'
     loader = PyPILoader(url)
 
     actual_load_status = loader.load()
     expected_snapshot_id = 'a27e638a4dad6fbfa273c6ebec1c4bf320fb84c6'
     assert actual_load_status == {
         'status': 'eventful',
         'snapshot_id': expected_snapshot_id,
     }
 
     expected_branches = {
         'releases/1.1.0/nexter-1.1.0.zip': {
             'target': '4c99891f93b81450385777235a37b5e966dd1571',
             'target_type': 'revision',
         },
         'releases/1.1.0/nexter-1.1.0.tar.gz': {
             'target': '0bf88f5760cca7665d0af4d6575d9301134fe11a',
             'target_type': 'revision',
         },
     }
 
     expected_snapshot = {
         'id': expected_snapshot_id,
         'branches': expected_branches,
     }
     check_snapshot(expected_snapshot, loader.storage)
 
     origin_visit = next(loader.storage.origin_visit_get(url))
     assert origin_visit['status'] == 'full'
     assert origin_visit['type'] == 'pypi'