pypiserver/tests/test_manage.py

#!/usr/bin/env py.test
"""Tests for manage.py."""

from __future__ import absolute_import, print_function, unicode_literals

try:
    from unittest.mock import Mock
except ImportError:
    from mock import Mock

import py
import pytest

from pypiserver import manage
from pypiserver.core import (
    PkgFile,
    guess_pkgname_and_version,
    parse_version,
)
from pypiserver.manage import (
    PipCmd,
    build_releases,
    filter_stable_releases,
    filter_latest_pkgs,
    is_stable_version,
    update_package,
    update_all_packages,
)


def touch_files(root, files):
    root = py.path.local(root)  # pylint: disable=no-member
    for f in files:
        root.join(f).ensure()


def pkgfile_from_path(fn):
    pkgname, version = guess_pkgname_and_version(fn)
    return PkgFile(pkgname=pkgname, version=version,
                   root=py.path.local(fn).parts()[1].strpath,  # noqa pylint: disable=no-member
                   fn=fn)


@pytest.mark.parametrize(
    ("version", "is_stable"),
    [("1.0", True),
     ("0.0.0", True),
     ("1.1beta1", False),
     ("1.2.10-123", True),
     ("5.5.0-DEV", False),
     ("1.2-rc1", False),
     ("1.0b1", False)])
def test_is_stable_version(version, is_stable):
    parsed_version = parse_version(version)
    assert is_stable_version(parsed_version) == is_stable


def test_build_releases():
    p = pkgfile_from_path('/home/ralf/pypiserver/d/greenlet-0.2.zip')

    expected = dict(parsed_version=('00000000', '00000003', '*final'),
                    pkgname='greenlet',
                    replaces=p,
                    version='0.3.0')

    res, = list(build_releases(p, ["0.3.0"]))
    for k, v in expected.items():
        assert getattr(res, k) == v


def test_filter_stable_releases():
    p = pkgfile_from_path('/home/ralf/pypiserver/d/greenlet-0.2.zip')
    assert list(filter_stable_releases([p])) == [p]

    p2 = pkgfile_from_path('/home/ralf/pypiserver/d/greenlet-0.5rc1.zip')
    assert list(filter_stable_releases([p2])) == []


def test_filter_latest_pkgs():
    paths = ["/home/ralf/greenlet-0.2.zip",
             "/home/ralf/foo/baz-1.0.zip"
             "/home/ralf/bar/greenlet-0.3.zip"]
    pkgs = [pkgfile_from_path(x) for x in paths]

    assert frozenset(filter_latest_pkgs(pkgs)) == frozenset(pkgs[1:])


def test_filter_latest_pkgs_case_insensitive():
    paths = ["/home/ralf/greenlet-0.2.zip",
             "/home/ralf/foo/baz-1.0.zip"
             "/home/ralf/bar/Greenlet-0.3.zip"]
    pkgs = [pkgfile_from_path(x) for x in paths]

    assert frozenset(filter_latest_pkgs(pkgs)) == frozenset(pkgs[1:])


@pytest.mark.parametrize('pip_ver, cmd_type', (
    ('10.0.0', 'd'),
    ('10.0.0rc10', 'd'),
    ('10.0.0b10', 'd'),
    ('10.0.0a3', 'd'),
    ('10.0.0.dev8', 'd'),
    ('10.0.0.dev8', 'd'),
    ('18.0', 'd'),
    ('9.9.8', 'i'),
    ('9.9.8rc10', 'i'),
    ('9.9.8b10', 'i'),
    ('9.9.8a10', 'i'),
    ('9.9.8.dev10', 'i'),
    ('9.9', 'i'),
))
def test_pip_cmd_root(pip_ver, cmd_type):
    """Verify correct determination of the command root by pip version."""
    exp_cmd = (
        'pip',
        '-q',
        'install' if cmd_type == 'i' else 'download',
    )
    assert tuple(PipCmd.update_root(pip_ver)) == exp_cmd


def test_pip_cmd_update():
    """Verify the correct determination of a pip command."""
    index = 'https://pypi.org/simple'
    destdir = 'foo/bar'
    pkg_name = 'mypkg'
    pkg_version = '12.0'
    cmd_root = ('pip', '-q', 'download')
    exp_cmd = cmd_root + (
        '--no-deps',
        '-i',
        index,
        '-d',
        destdir,
        '{}=={}'.format(pkg_name, pkg_version)
    )
    assert exp_cmd == tuple(
        PipCmd.update(cmd_root, destdir, pkg_name, pkg_version)
    )


def test_pip_cmd_update_index_overridden():
    """Verify the correct determination of a pip command."""
    index = 'https://pypi.org/complex'
    destdir = 'foo/bar'
    pkg_name = 'mypkg'
    pkg_version = '12.0'
    cmd_root = ('pip', '-q', 'download')
    exp_cmd = cmd_root + (
        '--no-deps',
        '-i', index,
        '-d', destdir,
        '{}=={}'.format(pkg_name, pkg_version)
    )
    assert exp_cmd == tuple(
        PipCmd.update(cmd_root, destdir, pkg_name, pkg_version, index=index)
    )


def test_update_package(monkeypatch):
    """Test generating an update command for a package."""
    monkeypatch.setattr(manage, 'call', Mock())
    pkg = PkgFile('mypkg', '1.0', replaces=PkgFile('mypkg', '0.9'))
    update_package(pkg, '.')
    manage.call.assert_called_once_with((  # pylint: disable=no-member
        'pip',
        '-q',
        'download',
        '--no-deps',
        '-i', 'https://pypi.org/simple',
        '-d', '.',
        'mypkg==1.0',
    ))


def test_update_package_dry_run(monkeypatch):
    """Test generating an update command for a package."""
    monkeypatch.setattr(manage, 'call', Mock())
    pkg = PkgFile('mypkg', '1.0', replaces=PkgFile('mypkg', '0.9'))
    update_package(pkg, '.', dry_run=True)
    assert not manage.call.mock_calls  # pylint: disable=no-member


def test_update_all_packages(monkeypatch):
    """Test calling update_all_packages()"""
    public_pkg_1 = PkgFile('Flask', '1.0')
    public_pkg_2 = PkgFile('requests', '1.0')
    private_pkg_1 = PkgFile('my_private_pkg', '1.0')
    private_pkg_2 = PkgFile('my_other_private_pkg', '1.0')

    roots_mock = {
        '/opt/pypi': [
            public_pkg_1,
            private_pkg_1,
        ],
        '/data/pypi': [
            public_pkg_2,
            private_pkg_2
        ],
    }

    def core_listdir_mock(directory):
        return roots_mock.get(directory, [])

    monkeypatch.setattr(manage.core, 'listdir', core_listdir_mock)
    monkeypatch.setattr(manage.core, 'read_lines', Mock(return_value=[]))
    monkeypatch.setattr(manage, 'update', Mock(return_value=None))

    destdir = None
    dry_run = False
    stable_only = True
    blacklist_file = None

    update_all_packages(
        roots=list(roots_mock.keys()),
        destdir=destdir,
        dry_run=dry_run,
        stable_only=stable_only,
        blacklist_file=blacklist_file,
    )

    manage.core.read_lines.assert_not_called()   # pylint: disable=no-member
    manage.update.assert_called_once_with(   # pylint: disable=no-member
        frozenset([public_pkg_1, public_pkg_2, private_pkg_1, private_pkg_2]),
        destdir,
        dry_run,
        stable_only
    )


def test_update_all_packages_with_blacklist(monkeypatch):
    """Test calling update_all_packages()"""
    public_pkg_1 = PkgFile('Flask', '1.0')
    public_pkg_2 = PkgFile('requests', '1.0')
    private_pkg_1 = PkgFile('my_private_pkg', '1.0')
    private_pkg_2 = PkgFile('my_other_private_pkg', '1.0')

    roots_mock = {
        '/opt/pypi': [
            public_pkg_1,
            private_pkg_1,
        ],
        '/data/pypi': [
            public_pkg_2,
            private_pkg_2
        ],
    }

    def core_listdir_mock(directory):
        return roots_mock.get(directory, [])

    monkeypatch.setattr(manage.core, 'listdir', core_listdir_mock)
    monkeypatch.setattr(manage.core, 'read_lines', Mock(return_value=['my_private_pkg', 'my_other_private_pkg']))
    monkeypatch.setattr(manage, 'update', Mock(return_value=None))

    destdir = None
    dry_run = False
    stable_only = True
    blacklist_file = '/root/pkg_blacklist'

    update_all_packages(
        roots=list(roots_mock.keys()),
        destdir=destdir,
        dry_run=dry_run,
        stable_only=stable_only,
        blacklist_file=blacklist_file,
    )

    manage.update.assert_called_once_with(   # pylint: disable=no-member
        frozenset([public_pkg_1, public_pkg_2]),
        destdir,
        dry_run,
        stable_only
    )
    manage.core.read_lines.assert_called_once_with(blacklist_file)   # pylint: disable=no-member