Hydrilla

[submodule "hydrilla-json-schemas"]

[submodule "hydrilla-source-package-example"]

[submodule "hydrilla-source-package-example-apt"]

	path = tests/source-package-example-apt

	url = ../hydrilla-source-package-example-apt

markers = [

    "subprocess_run: define how mocked subprocess.run should behave"

]

# SPDX-License-Identifier: AGPL-3.0-or-later

# Using a local APT.

#

# This file is part of Hydrilla

#

# Copyright (C) 2022 Wojtek Kosior

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as

# published by the Free Software Foundation, either version 3 of the

# License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

#

#

# I, Wojtek Kosior, thereby promise not to sue for violation of this

# file's license. Although I request that you do not make use this code

# in a proprietary program, I am not going to enforce this in court.

# Enable using with Python 3.7.

from __future__ import annotations

import zipfile

import shutil

import re

import subprocess

CP = subprocess.CompletedProcess

from pathlib import Path

from tempfile import TemporaryDirectory, NamedTemporaryFile

from hashlib import sha256

from contextlib import contextmanager

from typing import Optional, Iterable

from .. import util

here = Path(__file__).resolve().parent

_ = util.translation(here / 'locales').gettext

"""

Default cache directory to save APT configurations and downloaded GPG keys in.

"""

default_apt_cache_dir = Path.home() / '.cache' / 'hydrilla' / 'builder' / 'apt'

"""

Default keyserver to use.

"""

default_keyserver = 'hkps://keyserver.ubuntu.com:443'

"""

Default keys to download when using a local APT.

"""

default_keys = [

    # Trisquel

    'B4EFB9F38D8AEBF1', 'B138CA450C05112F',

    # Ubuntu

    '40976EAF437D05B5', '3B4FE6ACC0B21F32', '871920D1991BC93C',

    # Debian

    '9D6D8F6BC857C906', '8B48AD6246925553', 'DCC9EFBF77E11517', '648ACFD622F3D138',

    '54404762BBB6E853'

]

"""sources.list file contents for known distros."""

default_lists = {

    'nabia': [f'{type} http://archive.trisquel.info/trisquel/ nabia{suf} main'

              for type in ('deb', 'deb-src')

              for suf in ('', '-updates', '-security')]

}

class GpgError(Exception):

    """

    Exception used to report various problems when calling GPG.

    """

class DistroError(Exception):

    """

    Exception used to report problems when resolving an OS distribution.

    """

class AptError(Exception):

    """

    Exception used to report various problems when calling apt-* commands.

    """

    def __init__(self, msg: str, cp: Optional[CP]=None) -> None:

        """Initialize this AptError"""

        if cp and cp.stdout:

            msg = '\n\n'.join([msg, _('STDOUT_OUTPUT_heading'), cp.stdout])

        if cp and cp.stderr:

            msg = '\n\n'.join([msg, _('STDERR_OUTPUT_heading'), cp.stderr])

        super().__init__(msg)

class Apt:

    """

    This class represents an APT instance and can be used to call apt-get

    commands with it.

    """

    def __init__(self, apt_conf: str) -> None:

        """Initialize this Apt object."""

        self.apt_conf = apt_conf

    def get(self, *args: str, **kwargs) -> CP:

        """

        Run apt-get with the specified arguments and raise a meaningful AptError

        when something goes wrong.

        """

        command = ['apt-get', '-c', self.apt_conf, *args]

        try:

            cp = subprocess.run(command, **kwargs, env={'LANG': 'en_US'},

                                capture_output=True, text=True)

        except FileNotFoundError:

            raise AptError(_('couldnt_execute_apt_get_is_it_installed'))

        if cp.returncode != 0:

            msg = _('apt_get_command_{}_failed').format(' '.join(command))

            raise AptError(msg, cp)

        return cp

def cache_dir() -> Path:

    """

    Return the directory used to cache data (APT configurations, keyrings) to

    speed up repeated operations.

    This function first ensures the directory exists.

    """

    default_apt_cache_dir.mkdir(parents=True, exist_ok=True)

    return default_apt_cache_dir

class SourcesList:

    """Representation of apt's sources.list contents."""

    def __init__(self, list: [str]=[], codename: Optional[str]=None) -> None:

        """Initialize this SourcesList."""

        self.codename = None

        self.list = [*list]

        self.has_extra_entries = bool(self.list)

        if codename is not None:

            if codename not in default_lists:

                raise DistroError(_('distro_{}_unknown').format(codename))

            self.codename = codename

            self.list.extend(default_lists[codename])

    def identity(self) -> str:

        """

        Produce a string that uniquely identifies this sources.list contents.

        """

        if self.codename and not self.has_extra_entries:

            return self.codename

        return sha256('\n'.join(sorted(self.list)).encode()).digest().hex()

def apt_conf(directory: Path) -> str:

    """

    Given local APT's directory, produce a configuration suitable for running

    APT there.

    'directory' must not contain any special characters including quotes and

    spaces.

    """

    return f'''

Dir "{directory}";

Dir::State "{directory}/var/lib/apt";

Dir::State::status "{directory}/var/lib/dpkg/status";

Dir::Etc::SourceList "{directory}/etc/apt.sources.list";

Dir::Etc::SourceParts "";

Dir::Cache "{directory}/var/cache/apt";

pkgCacheGen::Essential "none";

Dir::Etc::Trusted "{directory}/etc/trusted.gpg";

'''

def apt_keyring(keys: [str]) -> bytes:

    """

    Download the requested keys if necessary and export them as a keyring

    suitable for passing to APT.

    The keyring is returned as a bytes value that should be written to a file.

    """

    try:

        from gnupg import GPG

    except ModuleNotFoundError:

        raise GpgError(_('couldnt_import_gnupg_is_it_installed'))

    gpg = GPG(keyring=str(cache_dir() / 'master_keyring.gpg'))

    for key in keys:

        if gpg.list_keys(keys=[key]) != []:

            continue

        if gpg.recv_keys(default_keyserver, key).imported == 0:

            raise GpgError(_('gpg_couldnt_recv_key'))

    return gpg.export_keys(keys, armor=False, minimal=True)

def cache_apt_root(apt_root: Path, destination_zip: Path) -> None:

    """

    Zip an APT root directory for later use and move the zipfile to the

    requested destination.

    """

    temporary_zip_path = None

    try:

        tmpfile = NamedTemporaryFile(suffix='.zip', prefix='tmp_',

                                     dir=cache_dir(), delete=False)

        temporary_zip_path = Path(tmpfile.name)

        to_skip = {Path('etc') / 'apt.conf', Path('etc') / 'trusted.gpg'}

        with zipfile.ZipFile(tmpfile, 'w') as zf:

            for member in apt_root.rglob('*'):

                relative = member.relative_to(apt_root)

                if relative not in to_skip:

                    # This call will also properly add empty folders to zip file

                    zf.write(member, relative, zipfile.ZIP_DEFLATED)

        shutil.move(temporary_zip_path, destination_zip)

    finally:

        if temporary_zip_path is not None and temporary_zip_path.exists():

            temporary_zip_path.unlink()

def setup_local_apt(directory: Path, list: SourcesList, keys: [str]) -> Apt:

    """

    Create files and directories necessary for running APT without root rights

    inside 'directory'.

    'directory' must not contain any special characters including quotes and

    spaces and must be empty.

    Return an Apt object that can be used to call apt-get commands.

    """

    apt_root = directory / 'apt_root'

    conf_text     = apt_conf(apt_root)

    keyring_bytes = apt_keyring(keys)

    apt_zipfile = cache_dir() / f'apt_{list.identity()}.zip'

    if apt_zipfile.exists():

        with zipfile.ZipFile(apt_zipfile) as zf:

            zf.extractall(apt_root)

    for to_create in (

            apt_root / 'var' / 'lib' / 'apt' / 'partial',

            apt_root / 'var' / 'lib' / 'apt' / 'lists',

            apt_root / 'var' / 'cache' / 'apt' / 'archives' / 'partial',

            apt_root / 'etc' / 'apt' / 'preferences.d',

            apt_root / 'var' / 'lib' / 'dpkg',

            apt_root / 'var' / 'log' / 'apt'

    ):

        to_create.mkdir(parents=True, exist_ok=True)

    conf_path    = apt_root / 'etc' / 'apt.conf'

    trusted_path = apt_root / 'etc' / 'trusted.gpg'

    status_path  = apt_root / 'var' / 'lib' / 'dpkg' / 'status'

    list_path    = apt_root / 'etc' / 'apt.sources.list'

    conf_path.write_text(conf_text)

    trusted_path.write_bytes(keyring_bytes)

    status_path.touch()

    list_path.write_text('\n'.join(list.list))

    apt = Apt(str(conf_path))

    apt.get('update')

    cache_apt_root(apt_root, apt_zipfile)

    return apt

@contextmanager

def local_apt(list: SourcesList, keys: [str]) -> Iterable[Apt]:

    """

    Create a temporary directory with proper local APT configuration in it.

    Yield an Apt object that can be used to issue apt-get commands.

    This function returns a context manager that will remove the directory on

    close.

    """

    with TemporaryDirectory() as td:

        td = Path(td)

        yield setup_local_apt(td, list, keys)

def download_apt_packages(list: SourcesList, keys: [str], packages: [str],

                          destination_dir: Path, with_deps=False) -> [str]:

    """

    Set up a local APT, update it using the specified sources.list configuration

    and use it to download the specified packages.

    This function downloads a .deb file of the packages matching the current

    architecture (which includes packages with architecture 'all') as well as

    all theis corresponding source package files and (if requested) the debs

    and source files of all their declared dependencies.

    Return value is a list of names of all downloaded files.

    """

    with local_apt(list, keys) as apt:

        if with_deps:

            cp = apt.get('install', '--yes', '--just-print', *packages)

            deps_listing = re.match(

                r'''

                .*

                The\sfollowing\sNEW\spackages\swill\sbe\sinstalled:

                (.*)

                0\supgraded,

                ''',

                cp.stdout,

                re.MULTILINE | re.DOTALL | re.VERBOSE)

            if deps_listing is None:

                raise AptError(_('apt_install_output_not_understood'), cp)

            packages = deps_listing.group(1).split()

        # Download .debs to indirectly to destination_dir by first placing them

        # in a temporary subdirectory.

        with TemporaryDirectory(dir=destination_dir) as td:

            td = Path(td)

            cp = apt.get('download', *packages, cwd=td)

            deb_name_regex = re.compile(

                r'''

                ^

                (?P<name>[^_]+)

                _

                (?P<ver>[^_]+)

                _

                .+              # architecture (or 'all')

                \.deb

                $

                ''',

                re.VERBOSE)

            names_vers = []

            downloaded = []

            for deb_file in td.glob('*'):

                match = deb_name_regex.match(deb_file.name)

                if match is None:

                    msg = _('apt_download_gave_bad_filename_{}')\

                        .format(deb_file.name)

                    raise AptError(msg, cp)

                names_vers.append((match.group('name'), match.group('ver')))

                downloaded.append(deb_file.name)

            apt.get('source', '--download-only',

                    *[f'{n}={v}' for n, v in names_vers], cwd=td)

            for source_file in td.glob('*'):

                if source_file.name in downloaded:

                    continue

                downloaded.append(source_file.name)

            for filename in downloaded:

                shutil.move(td / filename, destination_dir / filename)

    return downloaded

Subproject commit 9294298e538fd5c9ef647270e6a48df85b4950f8

# SPDX-License-Identifier: CC0-1.0

# Copyright (C) 2022 Wojtek Kosior <koszko@koszko.org>

#

# Available under the terms of Creative Commons Zero v1.0 Universal.

# Enable using with Python 3.7.

from __future__ import annotations

import pytest

import tempfile

import re

from pathlib import Path

from zipfile import ZipFile

#from hashlib import sha256

from hydrilla.builder import local_apt

here = Path(__file__).resolve().parent

@pytest.fixture(autouse=True)

def no_requests(monkeypatch):

    """Remove requests.sessions.Session.request for all tests."""

    monkeypatch.delattr('requests.sessions.Session.request')

@pytest.fixture

def mock_cache_dir(monkeypatch):

    """Make local_apt.py cache files to a temporary directory."""

    with tempfile.TemporaryDirectory() as td:

        td_path = Path(td)

        monkeypatch.setattr(local_apt, 'default_apt_cache_dir', td_path)

        yield td_path

@pytest.fixture

def mock_gnupg_import(monkeypatch, mock_cache_dir):

    """Mock gnupg library when imported dynamically."""

    gnupg_mock_dir = mock_cache_dir / 'gnupg_mock'

    gnupg_mock_dir.mkdir()

    (gnupg_mock_dir / 'gnupg.py').write_text('GPG = None\n')

    monkeypatch.syspath_prepend(str(gnupg_mock_dir))

    import gnupg

    keyring_path = mock_cache_dir / 'master_keyring.gpg'

    class MockedImportResult:

        """gnupg.ImportResult replacement"""

        def __init__(self):

            """Initialize MockedImportResult object."""

            self.imported = 1

    class MockedGPG:

        """GPG replacement that does not really invoke GPG."""

        def __init__(self, keyring):

            """Verify the keyring path and initialize MockedGPG."""

            assert keyring == str(keyring_path)

            self.known_keys = {*keyring_path.read_text().split('\n')} \

                if keyring_path.exists() else set()

        def recv_keys(self, keyserver, key):

            """Mock key receiving - record requested key as received."""

            assert keyserver == local_apt.default_keyserver

            assert key not in self.known_keys

            self.known_keys.add(key)

            keyring_path.write_text('\n'.join(self.known_keys))

            return MockedImportResult()

        def list_keys(self, keys=None):

            """Mock key listing - return a list with dummy items."""

            if keys is None:

                return ['dummy'] * len(self.known_keys)

            else:

                return ['dummy' for k in keys if k in self.known_keys]

        def export_keys(self, keys, **kwargs):

            """

            Mock key export - check that the call has the expected arguments and

            return a dummy bytes array.

            """

            assert kwargs['armor']   == False

            assert kwargs['minimal'] == True

            assert {*keys} == self.known_keys

            return b'<dummy keys export>'

    monkeypatch.setattr(gnupg, 'GPG', MockedGPG)

class MockedCompletedProcess:

    """

    Object with some fields similar to those of subprocess.CompletedProcess.

    """

    def __init__(self, args, returncode, stdout, stderr):

        """Initialize MockedCompletedProcess"""

        self.args       = args

        self.returncode = returncode

        self.stdout     = stdout

        self.stderr     = stderr

"""

Output of 'apt-get install --yes --just-print libjs-mathjax' on some APT-based

system.

"""

sample_install_stdout = '''\

NOTE: This is only a simulation!

      apt-get needs root privileges for real execution.

      Keep also in mind that locking is deactivated,

      so don't depend on the relevance to the real current situation!

Reading package lists...

Building dependency tree...

Reading state information...

The following additional packages will be installed:

  fonts-mathjax

Suggested packages:

  fonts-mathjax-extras fonts-stix libjs-mathjax-doc

The following NEW packages will be installed:

  fonts-mathjax libjs-mathjax

0 upgraded, 2 newly installed, 0 to remove and 0 not upgraded.

Inst fonts-mathjax (2.7.9+dfsg-1 Devuan:4.0/stable, Devuan:1.0.0/unstable [all])

Inst libjs-mathjax (2.7.9+dfsg-1 Devuan:4.0/stable, Devuan:1.0.0/unstable [all])

Conf fonts-mathjax (2.7.9+dfsg-1 Devuan:4.0/stable, Devuan:1.0.0/unstable [all])

Conf libjs-mathjax (2.7.9+dfsg-1 Devuan:4.0/stable, Devuan:1.0.0/unstable [all])

'''

class MockedSubprocess:

    """subprocess with a run() function that does not spawn a process."""

    def __init__(self, update_return_value=0, install_return_value=0,

                 download_return_value=0, source_return_value=0):

        """Initialize MockedSubprocess object."""

        self.update_return_value   = update_return_value

        self.install_return_value  = install_return_value

        self.download_return_value = download_return_value

        self.source_return_value   = source_return_value

    def run(self, command, **kwargs):

        """

        Instead of running an 'apt-get update' command just touch some file

        in apt root to indicate that the call was made. Instead of running an

        'apt-get install' command just print a possible output of one. Instead

        if running an 'apt-get download' command just write some dummy .deb

        files to the appropriate directory.

        """

        assert kwargs['env'] == {'LANG': 'en_US'}

        assert kwargs['capture_output'] == True

        if 'update' in command:

            expected_command = ['apt-get', '-c', '<conf_path>', 'update']

        elif 'install' in command:

            expected_command = ['apt-get', '-c', '<conf_path>', 'install',

                                '--yes', '--just-print', 'libjs-mathjax']

        elif 'download' in command:

            expected_command = ['apt-get', '-c', '<conf_path>', 'download',

                                'libjs-mathjax']

            if 'fonts-mathjax' in command:

                expected_command.insert(-1, 'fonts-mathjax')

        elif 'source' in command:

            expected_command = ['apt-get', '-c', '<conf_path>', 'source',

                                '--download-only', 'libjs-mathjax=2.7.9+dfsg-1']

            if 'fonts-mathjax=2.7.9+dfsg-1' in command:

                if command[-1] == 'fonts-mathjax=2.7.9+dfsg-1':

                    expected_command.append('fonts-mathjax=2.7.9+dfsg-1')

                else:

                    expected_command.insert(-1, 'fonts-mathjax=2.7.9+dfsg-1')

        else:

            raise Exception(f'unknown apt command: {" ".join(command)}')

        assert len(expected_command) == len(command)

        for word, expected in zip(command, expected_command):

            if expected == '<conf_path>':

                conf_path = Path(word)

            else:

                assert word == expected

        if 'update' in command:

            (conf_path.parent / 'update_called').touch()

        if 'download' in command:

            destination = Path(kwargs.get('cwd') or Path.cwd())

            (destination / 'libjs-mathjax_2.7.9+dfsg-1_all.deb')\

                .write_text('dummy libjs-mathjax_2.7.9+dfsg-1_all.deb')

            if 'fonts-mathjax' in command:

                (destination / 'fonts-mathjax_2.7.9+dfsg-1_all.deb')\

                    .write_text('dummy fonts-mathjax_2.7.9+dfsg-1_all.deb')

        if 'source' in command:

            destination = Path(kwargs.get('cwd') or Path.cwd())

            for filename in [

                    'mathjax_2.7.9+dfsg-1.debian.tar.xz',

                    'mathjax_2.7.9+dfsg-1.dsc',

                    'mathjax_2.7.9+dfsg.orig.tar.xz'

            ]:

                (destination / filename).write_text(f'dummy {filename}')

        if kwargs.get('text'):

            stderr = 'some error output'

            stdout = 'some output'

            if 'install' in command:

                stdout = sample_install_stdout

        else:

            stdout = b'some bin output'

            stderr = b'some bin error output'

            if 'install' in command:

                stdout = sample_install_stdout.encode()

        return_val = (self.update_return_value   if 'update'   in command else \

                      self.install_return_value  if 'install'  in command else \

                      self.download_return_value if 'download' in command else \

                      self.source_return_value)

        return MockedCompletedProcess(command, return_val, stdout, stderr)

@pytest.fixture

def mock_apt_get_update(monkeypatch, request):

    """Mock 'apt-get update' command when called through subprocess.run."""

    marker = request.node.get_closest_marker('subprocess_run')

    run_mock_opts = marker.args[0] if marker else {}

    monkeypatch.setattr(local_apt, 'subprocess',

                        MockedSubprocess(**run_mock_opts))

class MockedSubprocessRaises:

    """subprocess with a run() function that always raises FileNotFoundError."""

    def run(self, command, **kwargs):

        """

        Instead of running an 'apt-get' command we act as if it was missing.

        """

        raise FileNotFoundError('dummy')

@pytest.fixture

def mock_apt_get_update_raises(monkeypatch):

    """Mock missing 'apt-get' command when called through subprocess.run."""

    monkeypatch.setattr(local_apt, 'subprocess', MockedSubprocessRaises())

def test_local_apt_contextmanager(mock_cache_dir, mock_apt_get_update,

                                  mock_gnupg_import):

    """

    Verify that the local_apt() function creates a proper apt environment and

    that it also properly restores it from cache.

    """

    sources_list = local_apt.SourcesList(['deb-src sth', 'deb sth'])

    with local_apt.local_apt(sources_list, local_apt.default_keys) as apt:

        apt_root = Path(apt.apt_conf).parent.parent

        assert (apt_root / 'etc' / 'trusted.gpg').read_bytes() == \

            b'<dummy keys export>'

        assert (apt_root / 'etc' / 'update_called').exists()

        assert (apt_root / 'etc' / 'apt.sources.list').read_text() == \

            'deb-src sth\ndeb sth'

        conf_lines = (apt_root / 'etc' / 'apt.conf').read_text().split('\n')

        # check mocked keyring

        assert {*local_apt.default_keys} == \

            {*(mock_cache_dir / 'master_keyring.gpg').read_text().split('\n')}

    assert not apt_root.exists()

    expected_conf = {

        'Dir':                    str(apt_root),

        'Dir::State':             f'{apt_root}/var/lib/apt',

        'Dir::State::status':     f'{apt_root}/var/lib/dpkg/status',

        'Dir::Etc::SourceList':   f'{apt_root}/etc/apt.sources.list',

        'Dir::Etc::SourceParts':  '',

        'Dir::Cache':             f'{apt_root}/var/cache/apt',

        'pkgCacheGen::Essential': 'none',

        'Dir::Etc::Trusted':      f'{apt_root}/etc/trusted.gpg',

    }

    conf_regex = re.compile(r'^(?P<key>\S+)\s"(?P<val>\S*)";$')

    assert dict([(m.group('key'), m.group('val'))

                 for l in conf_lines if l for m in [conf_regex.match(l)]]) == \

        expected_conf

    with ZipFile(mock_cache_dir / f'apt_{sources_list.identity()}.zip') as zf:

        # reuse the same APT, its cached zip file should exist now

        with local_apt.local_apt(sources_list, local_apt.default_keys) as apt:

            apt_root = Path(apt.apt_conf).parent.parent

            expected_members = {*apt_root.rglob('*')}

            expected_members.remove(apt_root / 'etc' / 'apt.conf')

            expected_members.remove(apt_root / 'etc' / 'trusted.gpg')

            names = zf.namelist()

            assert len(names) == len(expected_members)

            for name in names:

                path = apt_root / name

                assert path in expected_members

                assert zf.read(name) == \

                    (b'' if path.is_dir() else path.read_bytes())

    assert not apt_root.exists()

@pytest.mark.subprocess_run({'update_return_value': 1})

def test_local_apt_update_failing(mock_cache_dir, mock_apt_get_update,

                                  mock_gnupg_import):

    """

    Verify that the local_apt() function raises a proper error when

    'apt-get update' command returns non-0.

    """

    sources_list = local_apt.SourcesList(['deb-src sth', 'deb sth'])

    with pytest.raises(local_apt.AptError) as excinfo:

        with local_apt.local_apt(sources_list, local_apt.default_keys) as apt:

            pass

    assert len(excinfo.value.args) == 1

    assert re.match(r'.*\n\n.*\n\nsome output\n\n.*\n\nsome error output',

                    excinfo.value.args[0])

def test_local_apt_missing(mock_cache_dir, mock_apt_get_update_raises,

                           mock_gnupg_import):

    """

    Verify that the local_apt() function raises a proper error when 'apt-get'

    command is missing.

    """

    sources_list = local_apt.SourcesList(['deb-src sth', 'deb sth'])

    with pytest.raises(local_apt.AptError) as excinfo:

        with local_apt.local_apt(sources_list, local_apt.default_keys) as apt:

            pass

    assert len(excinfo.value.args) == 1

    assert isinstance(excinfo.value.args[0], str)

    assert '\n' not in excinfo.value.args[0]

def test_local_apt_download(mock_cache_dir, mock_apt_get_update,

                            mock_gnupg_import):

    """

    Verify that download_apt_packages() function properly performs the download

    of .debs and sources.

    """

    sources_list = local_apt.SourcesList(['deb-src sth', 'deb sth'])

    destination = mock_cache_dir / 'destination'

    destination.mkdir()

    local_apt.download_apt_packages(sources_list, local_apt.default_keys,

                                    ['libjs-mathjax'], destination)

    libjs_mathjax_path = destination / 'libjs-mathjax_2.7.9+dfsg-1_all.deb'

    fonts_mathjax_path = destination / 'fonts-mathjax_2.7.9+dfsg-1_all.deb'

    source_paths = [

        destination / 'mathjax_2.7.9+dfsg-1.debian.tar.xz',

        destination / 'mathjax_2.7.9+dfsg-1.dsc',

        destination / 'mathjax_2.7.9+dfsg.orig.tar.xz'

    ]

    assert {*destination.glob('*')} == {libjs_mathjax_path, *source_paths}

    local_apt.download_apt_packages(sources_list, local_apt.default_keys,

                                    ['libjs-mathjax'], destination,

                                    with_deps=True)

    assert {*destination.glob('*')} == \

        {libjs_mathjax_path, fonts_mathjax_path, *source_paths}

@pytest.mark.subprocess_run({'install_return_value': 1})

def test_local_apt_install_failing(mock_cache_dir, mock_apt_get_update,

                                   mock_gnupg_import):

    """

    Verify that the download_apt_packages() function raises a proper error when

    'apt-get install' command returns non-0.

    """

    sources_list = local_apt.SourcesList(['deb-src sth', 'deb sth'])

    destination = mock_cache_dir / 'destination'

    destination.mkdir()

    with pytest.raises(local_apt.AptError) as excinfo:

        local_apt.download_apt_packages(sources_list, local_apt.default_keys,

                                        ['libjs-mathjax'], destination,

                                        with_deps=True)

    assert len(excinfo.value.args) == 1

    assert re.match(r'^.*\n\n.*\n\n', excinfo.value.args[0])

    assert re.search(r'\n\nsome error output$', excinfo.value.args[0])

    assert sample_install_stdout in excinfo.value.args[0]

    assert [*destination.glob('*')] == []

@pytest.mark.subprocess_run({'download_return_value': 1})

def test_local_apt_download_failing(mock_cache_dir, mock_apt_get_update,

                                    mock_gnupg_import):

    """

    Verify that the download_apt_packages() function raises a proper error when

    'apt-get download' command returns non-0.

    """

    sources_list = local_apt.SourcesList(['deb-src sth', 'deb sth'])

    destination = mock_cache_dir / 'destination'

    destination.mkdir()

    with pytest.raises(local_apt.AptError) as excinfo:

        local_apt.download_apt_packages(sources_list, local_apt.default_keys,

                                        ['libjs-mathjax'], destination)

    assert len(excinfo.value.args) == 1

    assert re.match(r'.*\n\n.*\n\nsome output\n\n.*\n\nsome error output',

                    excinfo.value.args[0])

    assert [*destination.glob('*')] == []

@pytest.mark.subprocess_run({'source_return_value': 1})

def test_local_apt_source_failing(mock_cache_dir, mock_apt_get_update,

                                  mock_gnupg_import):

    """

    Verify that the download_apt_packages() function raises a proper error when

    'apt-get source' command returns non-0.

    """

    sources_list = local_apt.SourcesList(['deb-src sth', 'deb sth'])

    destination = mock_cache_dir / 'destination'

    destination.mkdir()

    with pytest.raises(local_apt.AptError) as excinfo:

        local_apt.download_apt_packages(sources_list, local_apt.default_keys,

                                        ['libjs-mathjax'], destination)

    assert len(excinfo.value.args) == 1

    assert re.match(r'.*\n\n.*\n\nsome output\n\n.*\n\nsome error output',

                    excinfo.value.args[0])

    assert [*destination.glob('*')] == []

def test_sources_list():

    list = local_apt.SourcesList([], 'nabia')

    assert list.identity() == 'nabia'

    with pytest.raises(local_apt.DistroError):

        local_apt.SourcesList([], 'nabiał')

    list = local_apt.SourcesList(['deb sth', 'deb-src sth'], 'nabia')

    assert list.identity() == \

        'ef28d408b96046eae45c8ab3094ce69b2ac0c02a887e796b1d3d1a4f06fb49f1'