Example #1
0
def test_download_should_skip_existing_files():
    """
    It should not download files already existing in the scratch dir
    """
    env = reset_env()

    write_file('test-req.txt', textwrap.dedent("""
        INITools==0.1
        """))

    result = run_pip('install', '-r', env.scratch_path/ 'test-req.txt', '-d', '.', expect_error=True)
    assert Path('scratch')/ 'INITools-0.1.tar.gz' in result.files_created
    assert env.site_packages/ 'initools' not in result.files_created

    # adding second package to test-req.txt
    write_file('test-req.txt', textwrap.dedent("""
        INITools==0.1
        python-openid==2.2.5
        """))

    # only the second package should be downloaded
    result = run_pip('install', '-r', env.scratch_path/ 'test-req.txt', '-d', '.', expect_error=True)
    openid_tarball_prefix = str(Path('scratch')/ 'python-openid-')
    assert any(path.startswith(openid_tarball_prefix) for path in result.files_created)
    assert Path('scratch')/ 'INITools-0.1.tar.gz' not in result.files_created
    assert env.site_packages/ 'initools' not in result.files_created
    assert env.site_packages/ 'openid' not in result.files_created
Example #2
0
def test_download_should_download_dependencies():
    """
    It should download dependencies (in the scratch path)
    """

    env = reset_env()
    result = run_pip('install', 'Paste[openid]==1.7.5.1', '-d', '.', expect_error=True)
    assert Path('scratch')/ 'Paste-1.7.5.1.tar.gz' in result.files_created
    openid_tarball_prefix = str(Path('scratch')/ 'python-openid-')
    assert any(path.startswith(openid_tarball_prefix) for path in result.files_created)
    assert env.site_packages/ 'openid' not in result.files_created
Example #3
0
def test_install_folder_using_relative_path():
    """
    Test installing a folder using pip install folder1/folder2
    """
    env = reset_env()
    mkdir('initools')
    mkdir(Path('initools') / 'mock')
    pkg_path = env.scratch_path / 'initools' / 'mock'
    write_file('setup.py', mock100_setup_py, pkg_path)
    result = run_pip('install', Path('initools') / 'mock')
    egg_folder = env.site_packages / 'mock-100.1-py%s.egg-info' % pyversion
    assert egg_folder in result.files_created, str(result)
Example #4
0
def test_create_bundle():
    """
    Test making a bundle.  We'll grab one package from the filesystem
    (the FSPkg dummy package), one from vcs (initools) and one from an
    index (pip itself).

    """
    env = reset_env()
    fspkg = path_to_url2(Path(here) / 'packages' / 'FSPkg')
    run_pip('install', '-e', fspkg)
    pkg_lines = textwrap.dedent(
        '''\
            -e %s
            -e %s#egg=initools-dev
            pip''' %
        (fspkg,
         local_checkout('svn+http://svn.colorstudy.com/INITools/trunk')))
    write_file('bundle-req.txt', pkg_lines)
    # Create a bundle in env.scratch_path/ test.pybundle
    result = run_pip('bundle', '-r', env.scratch_path / 'bundle-req.txt',
                     env.scratch_path / 'test.pybundle')
    bundle = result.files_after.get(join('scratch', 'test.pybundle'), None)
    assert bundle is not None

    files = zipfile.ZipFile(bundle.full).namelist()
    assert 'src/FSPkg/' in files
    assert 'src/initools/' in files
    assert 'build/pip/' in files
def test_install_package_with_target():
    """
    Test installing a package using pip install --target
    """
    env = reset_env()
    target_dir = env.scratch_path/'target'
    result = run_pip('install', '-t', target_dir, "initools==0.1")
    assert Path('scratch')/'target'/'initools' in result.files_created, str(result)
Example #6
0
def test_download_if_requested():
    """
    It should download (in the scratch path) and not install if requested.
    """

    env = reset_env()
    result = run_pip('install', 'INITools==0.1', '-d', '.', expect_error=True)
    assert Path('scratch') / 'INITools-0.1.tar.gz' in result.files_created
    assert env.site_packages / 'initools' not in result.files_created
Example #7
0
 def run(self, *args, **kw):
     if self.verbose:
         print('>> running %s %s' % (args, kw))
     cwd = kw.pop('cwd', None)
     run_from = kw.pop('run_from', None)
     assert not cwd or not run_from, "Don't use run_from; it's going away"
     cwd = Path.string(cwd or run_from or self.cwd)
     assert not isinstance(cwd, Path)
     return TestPipResult(super(TestPipEnvironment, self).run(cwd=cwd, *args, **kw), verbose=self.verbose)
Example #8
0
 def run(self, *args, **kw):
     if self.verbose:
         print('>> running %s %s' % (args, kw))
     cwd = kw.pop('cwd', None)
     run_from = kw.pop('run_from', None)
     assert not cwd or not run_from, "Don't use run_from; it's going away"
     cwd = Path.string(cwd or run_from or self.cwd)
     assert not isinstance(cwd, Path)
     return TestPipResult(super(TestPipEnvironment, self).run(cwd=cwd,
                                                              *args,
                                                              **kw),
                          verbose=self.verbose)
Example #9
0
def test_single_download_from_requirements_file():
    """
    It should support download (in the scratch path) from PyPi from a requirements file
    """

    env = reset_env()
    write_file('test-req.txt', textwrap.dedent("""
        INITools==0.1
        """))
    result = run_pip('install', '-r', env.scratch_path/ 'test-req.txt', '-d', '.', expect_error=True)
    assert Path('scratch')/ 'INITools-0.1.tar.gz' in result.files_created
    assert env.site_packages/ 'initools' not in result.files_created
Example #10
0
def test_download_editable_to_custom_path():
    """
    Test downloading an editable using a relative custom src folder.
    """
    reset_env()
    mkdir('customdl')
    result = run_pip(
        'install', '-e', '%s#egg=initools-dev' %
        local_checkout('svn+http://svn.colorstudy.com/INITools/trunk'),
        '--src', 'customsrc', '--download', 'customdl')
    customsrc = Path('scratch') / 'customsrc' / 'initools'
    assert customsrc in result.files_created, sorted(
        result.files_created.keys())
    assert customsrc / 'setup.py' in result.files_created, sorted(
        result.files_created.keys())

    customdl = Path('scratch') / 'customdl' / 'initools'
    customdl_files_created = [
        filename for filename in result.files_created
        if filename.startswith(customdl)
    ]
    assert customdl_files_created
def test_no_install_and_download_should_not_leave_build_dir():
    """
    It should remove build/ dir if it was pip that created
    """
    env = reset_env()
    mkdir('downloaded_packages')
    assert not os.path.exists(env.venv_path / '/build')
    result = run_pip('install', '--no-install', 'INITools==0.2', '-d',
                     'downloaded_packages')
    assert Path(
        'scratch'
    ) / 'downloaded_packages/build' not in result.files_created, 'pip should not leave build/ dir'
    assert not os.path.exists(
        env.venv_path / '/build'), "build/ dir should be deleted"
Example #12
0
def relpath(root, other):
    """a poor man's os.path.relpath, since we may not have Python 2.6"""
    prefix = root + Path.sep
    assert other.startswith(prefix)
    return Path(other[len(prefix):])
Example #13
0
    def __init__(self, environ=None, sitecustomize=None):
        import virtualenv

        self.root_path = fast_test_env_root
        self.backup_path = fast_test_env_backup

        self.scratch_path = self.root_path / self.scratch

        # We will set up a virtual environment at root_path.
        self.venv_path = self.root_path / self.venv

        if not environ:
            environ = os.environ.copy()
            environ = clear_environ(environ)
            environ['PIP_DOWNLOAD_CACHE'] = str(download_cache)

        environ['PIP_NO_INPUT'] = '1'
        environ['PIP_LOG_FILE'] = str(self.root_path / 'pip-log.txt')

        TestFileEnvironment.__init__(self,
                                     self.root_path,
                                     ignore_hidden=False,
                                     environ=environ,
                                     split_cmd=False,
                                     start_clear=False,
                                     cwd=self.scratch_path,
                                     capture_temp=True,
                                     assert_no_temp=True)

        virtualenv_paths = virtualenv.path_locations(self.venv_path)

        for id, path in zip(('venv', 'lib', 'include', 'bin'),
                            virtualenv_paths):
            #fix for virtualenv issue #306
            if hasattr(sys, "pypy_version_info") and id == 'lib':
                path = os.path.join(self.venv_path, 'lib-python', pyversion)
            setattr(self, id + '_path', Path(path))
            setattr(self, id, relpath(self.root_path, path))

        assert self.venv == TestPipEnvironment.venv  # sanity check

        if hasattr(sys, "pypy_version_info"):
            self.site_packages = self.venv / 'site-packages'
        else:
            self.site_packages = self.lib / 'site-packages'
        self.user_base_path = self.venv_path / 'user'
        self.user_site_path = self.venv_path / 'user' / 'lib' / self.lib.name / 'site-packages'

        self.user_site = relpath(self.root_path, self.user_site_path)

        self.environ["PYTHONUSERBASE"] = self.user_base_path

        # put the test-scratch virtualenv's bin dir first on the PATH
        self.environ['PATH'] = Path.pathsep.join(
            (self.bin_path, self.environ['PATH']))

        self.use_distribute = os.environ.get('PIP_TEST_USE_DISTRIBUTE', False)

        if self.root_path.exists:
            rmtree(self.root_path)
        if self.backup_path.exists:
            shutil.copytree(self.backup_path, self.root_path, True)
        else:
            demand_dirs(self.venv_path)
            demand_dirs(self.scratch_path)

            # Create a virtualenv and remember where it's putting things.
            create_virtualenv(self.venv_path, distribute=self.use_distribute)

            demand_dirs(self.user_site_path)

            # create easy-install.pth in user_site, so we always have it updated instead of created
            open(self.user_site_path / 'easy-install.pth', 'w').close()

            # test that test-scratch virtualenv creation produced sensible venv python
            result = self.run('python', '-c',
                              'import sys; print(sys.executable)')
            pythonbin = result.stdout.strip()

            if Path(pythonbin).noext != self.bin_path / 'python':
                raise RuntimeError(
                    "Oops! 'python' in our test environment runs %r"
                    " rather than expected %r" %
                    (pythonbin, self.bin_path / 'python'))

            # make sure we have current setuptools to avoid svn incompatibilities
            if not self.use_distribute:
                install_setuptools(self)

            # Uninstall whatever version of pip came with the virtualenv.
            # Earlier versions of pip were incapable of
            # self-uninstallation on Windows, so we use the one we're testing.
            self.run(
                'python', '-c',
                '"import sys; sys.path.insert(0, %r); import pip; sys.exit(pip.main());"'
                % os.path.dirname(here), 'uninstall', '-vvv', '-y', 'pip')

            # Install this version instead
            self.run('python',
                     'setup.py',
                     'install',
                     cwd=src_folder,
                     expect_stderr=True)
            # Install snakebasket as well
            self.run('python',
                     'setup.py',
                     'install',
                     cwd=os.path.abspath(os.path.join(src_folder, '../')),
                     expect_stderr=True)
            # Backup up test dir
            shutil.copytree(self.root_path, self.backup_path, True)
        #create sitecustomize.py and add patches
        self._create_empty_sitecustomize()
        self._use_cached_pypi_server()
        if sitecustomize:
            self._add_to_sitecustomize(sitecustomize)

        assert self.root_path.exists

        # Ensure that $TMPDIR exists (because we use start_clear=False, it's not created for us)
        if self.temp_path and not os.path.exists(self.temp_path):
            os.makedirs(self.temp_path)
Example #14
0
class TestPipEnvironment(TestFileEnvironment):
    """A specialized TestFileEnvironment for testing pip"""

    #
    # Attribute naming convention
    # ---------------------------
    #
    # Instances of this class have many attributes representing paths
    # in the filesystem.  To keep things straight, absolute paths have
    # a name of the form xxxx_path and relative paths have a name that
    # does not end in '_path'.

    # The following paths are relative to the root_path, and should be
    # treated by clients as instance attributes.  The fact that they
    # are defined in the class is an implementation detail

    # where we'll create the virtual Python installation for testing
    #
    # Named with a leading dot to reduce the chance of spurious
    # results due to being mistaken for the virtualenv package.
    venv = Path('.virtualenv')

    # The root of a directory tree to be used arbitrarily by tests
    scratch = Path('scratch')

    exe = sys.platform == 'win32' and '.exe' or ''

    verbose = False

    def __init__(self, environ=None, use_distribute=None, sitecustomize=None):

        self.root_path = Path(tempfile.mkdtemp('-piptest'))

        # We will set up a virtual environment at root_path.
        self.scratch_path = self.root_path / self.scratch

        self.venv_path = self.root_path / self.venv

        if not environ:
            environ = os.environ.copy()
            environ = clear_environ(environ)
            environ['PIP_DOWNLOAD_CACHE'] = str(download_cache)

        environ['PIP_NO_INPUT'] = '1'
        environ['PIP_LOG_FILE'] = str(self.root_path / 'pip-log.txt')

        super(TestPipEnvironment, self).__init__(self.root_path,
                                                 ignore_hidden=False,
                                                 environ=environ,
                                                 split_cmd=False,
                                                 start_clear=False,
                                                 cwd=self.scratch_path,
                                                 capture_temp=True,
                                                 assert_no_temp=True)

        demand_dirs(self.venv_path)
        demand_dirs(self.scratch_path)

        if use_distribute is None:
            use_distribute = os.environ.get('PIP_TEST_USE_DISTRIBUTE', False)
        self.use_distribute = use_distribute

        # Create a virtualenv and remember where it's putting things.
        virtualenv_paths = create_virtualenv(self.venv_path,
                                             distribute=self.use_distribute)

        assert self.venv_path == virtualenv_paths[0]  # sanity check

        for id, path in zip(('venv', 'lib', 'include', 'bin'),
                            virtualenv_paths):
            #fix for virtualenv issue #306
            if hasattr(sys, "pypy_version_info") and id == 'lib':
                path = os.path.join(self.venv_path, 'lib-python', pyversion)
            setattr(self, id + '_path', Path(path))
            setattr(self, id, relpath(self.root_path, path))

        assert self.venv == TestPipEnvironment.venv  # sanity check

        if hasattr(sys, "pypy_version_info"):
            self.site_packages = self.venv / 'site-packages'
        else:
            self.site_packages = self.lib / 'site-packages'
        self.user_base_path = self.venv_path / 'user'
        self.user_site_path = self.venv_path / 'user' / site_packages_suffix

        self.user_site = relpath(self.root_path, self.user_site_path)
        demand_dirs(self.user_site_path)
        self.environ["PYTHONUSERBASE"] = self.user_base_path

        # create easy-install.pth in user_site, so we always have it updated instead of created
        open(self.user_site_path / 'easy-install.pth', 'w').close()

        # put the test-scratch virtualenv's bin dir first on the PATH
        self.environ['PATH'] = Path.pathsep.join(
            (self.bin_path, self.environ['PATH']))

        # test that test-scratch virtualenv creation produced sensible venv python
        result = self.run('python', '-c', 'import sys; print(sys.executable)')
        pythonbin = result.stdout.strip()

        if Path(pythonbin).noext != self.bin_path / 'python':
            raise RuntimeError("Oops! 'python' in our test environment runs %r"
                               " rather than expected %r" %
                               (pythonbin, self.bin_path / 'python'))

        # make sure we have current setuptools to avoid svn incompatibilities
        if not self.use_distribute:
            install_setuptools(self)

        # Uninstall whatever version of pip came with the virtualenv.
        # Earlier versions of pip were incapable of
        # self-uninstallation on Windows, so we use the one we're testing.
        self.run(
            'python', '-c',
            '"import sys; sys.path.insert(0, %r); import pip; sys.exit(pip.main());"'
            % os.path.dirname(here), 'uninstall', '-vvv', '-y', 'pip')

        # Install this version instead
        self.run('python',
                 'setup.py',
                 'install',
                 cwd=src_folder,
                 expect_stderr=True)
        # Install snakebasket as well
        self.run('python',
                 'setup.py',
                 'install',
                 cwd=os.path.abspath(os.path.join(src_folder, '../')),
                 expect_stderr=True)

        #create sitecustomize.py and add patches
        self._create_empty_sitecustomize()
        self._use_cached_pypi_server()
        if sitecustomize:
            self._add_to_sitecustomize(sitecustomize)

        # Ensure that $TMPDIR exists  (because we use start_clear=False, it's not created for us)
        if self.temp_path and not os.path.exists(self.temp_path):
            os.makedirs(self.temp_path)

    def _ignore_file(self, fn):
        if fn.endswith('__pycache__') or fn.endswith(".pyc"):
            result = True
        else:
            result = super(TestPipEnvironment, self)._ignore_file(fn)
        return result

    def run(self, *args, **kw):
        if self.verbose:
            print('>> running %s %s' % (args, kw))
        cwd = kw.pop('cwd', None)
        run_from = kw.pop('run_from', None)
        assert not cwd or not run_from, "Don't use run_from; it's going away"
        cwd = Path.string(cwd or run_from or self.cwd)
        assert not isinstance(cwd, Path)
        return TestPipResult(super(TestPipEnvironment, self).run(cwd=cwd,
                                                                 *args,
                                                                 **kw),
                             verbose=self.verbose)

    def __del__(self):
        rmtree(str(self.root_path), ignore_errors=True)

    def _use_cached_pypi_server(self):
        # previously, this was handled in a pth file, and not in sitecustomize.py
        # pth processing happens during the construction of sys.path.
        # 'import pypi_server' ultimately imports pkg_resources (which intializes pkg_resources.working_set based on the current state of sys.path)
        # pkg_resources.get_distribution (used in pip.req) requires an accurate pkg_resources.working_set
        # therefore, 'import pypi_server' shouldn't occur in a pth file.
        official_pip_tests_dir = os.path.abspath(
            os.path.join(str(here), '../pip/tests'))

        patch = """
            import sys
            sys.path.insert(0, %r)
            import pypi_server
            pypi_server.PyPIProxy.setup()
            sys.path.remove(%r)""" % (official_pip_tests_dir,
                                      official_pip_tests_dir)
        self._add_to_sitecustomize(patch)

    def _create_empty_sitecustomize(self):
        "Create empty sitecustomize.py."
        sitecustomize_path = self.lib_path / 'sitecustomize.py'
        sitecustomize = open(sitecustomize_path, 'w')
        sitecustomize.close()

    def _add_to_sitecustomize(self, snippet):
        "Adds a python code snippet to sitecustomize.py."
        sitecustomize_path = self.lib_path / 'sitecustomize.py'
        sitecustomize = open(sitecustomize_path, 'a')
        sitecustomize.write(
            textwrap.dedent('''
                               %s
        ''' % snippet))
        sitecustomize.close()
Example #15
0
    def __init__(self, environ=None, use_distribute=None):

        self.root_path = Path(tempfile.mkdtemp('-piptest'))

        # We will set up a virtual environment at root_path.
        self.scratch_path = self.root_path / self.scratch

        self.venv_path = self.root_path / self.venv

        if not environ:
            environ = os.environ.copy()
            environ = clear_environ(environ)
            environ['PIP_DOWNLOAD_CACHE'] = str(download_cache)

        environ['PIP_NO_INPUT'] = '1'
        environ['PIP_LOG_FILE'] = str(self.root_path / 'pip-log.txt')

        super(TestPipEnvironment, self).__init__(self.root_path,
                                                 ignore_hidden=False,
                                                 environ=environ,
                                                 split_cmd=False,
                                                 start_clear=False,
                                                 cwd=self.scratch_path,
                                                 capture_temp=True,
                                                 assert_no_temp=True)

        demand_dirs(self.venv_path)
        demand_dirs(self.scratch_path)

        if use_distribute is None:
            use_distribute = os.environ.get('PIP_TEST_USE_DISTRIBUTE', False)

        # Create a virtualenv and remember where it's putting things.
        virtualenv_paths = create_virtualenv(self.venv_path,
                                             distribute=use_distribute)

        assert self.venv_path == virtualenv_paths[0]  # sanity check

        for id, path in zip(('venv', 'lib', 'include', 'bin'),
                            virtualenv_paths):
            setattr(self, id + '_path', Path(path))
            setattr(self, id, relpath(self.root_path, path))

        assert self.venv == TestPipEnvironment.venv  # sanity check

        self.site_packages = self.lib / 'site-packages'
        self.user_base_path = self.venv_path / 'user'
        self.user_site_path = self.venv_path / 'user' / 'lib' / self.lib.name / 'site-packages'

        self.user_site = relpath(self.root_path, self.user_site_path)
        demand_dirs(self.user_site_path)
        self.environ["PYTHONUSERBASE"] = self.user_base_path

        # create easy-install.pth in user_site, so we always have it updated instead of created
        open(self.user_site_path / 'easy-install.pth', 'w').close()

        # put the test-scratch virtualenv's bin dir first on the PATH
        self.environ['PATH'] = Path.pathsep.join(
            (self.bin_path, self.environ['PATH']))

        # test that test-scratch virtualenv creation produced sensible venv python
        result = self.run('python', '-c', 'import sys; print(sys.executable)')
        pythonbin = result.stdout.strip()

        if Path(pythonbin).noext != self.bin_path / 'python':
            raise RuntimeError("Oops! 'python' in our test environment runs %r"
                               " rather than expected %r" %
                               (pythonbin, self.bin_path / 'python'))

        # make sure we have current setuptools to avoid svn incompatibilities
        if not use_distribute:
            install_setuptools(self)

        # Uninstall whatever version of pip came with the virtualenv.
        # Earlier versions of pip were incapable of
        # self-uninstallation on Windows, so we use the one we're testing.
        self.run(
            'python', '-c',
            '"import sys; sys.path.insert(0, %r); import pip; sys.exit(pip.main());"'
            % os.path.dirname(here), 'uninstall', '-vvv', '-y', 'pip')

        # Install this version instead
        self.run('python',
                 'setup.py',
                 'install',
                 cwd=src_folder,
                 expect_stderr=True)
        self._use_cached_pypi_server()
Example #16
0
import os
import sys
import tempfile
import shutil
import glob
import atexit
import textwrap
import site
import imp

from scripttest import TestFileEnvironment, FoundDir
from tests.path import Path, curdir, u

pyversion = sys.version[:3]
# the directory containing all the tests
here = Path(__file__).abspath.folder
# the directory containing all the tests
src_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), '../pip'))

# the root of this pip source distribution
download_cache = tempfile.mkdtemp(prefix='pip-test-cache')
site_packages_suffix = site.USER_SITE[len(site.USER_BASE) + 1:]

# Tweak the path so we can find up-to-date pip sources
# (http://bitbucket.org/ianb/pip/issue/98)
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'pip'))

from pip.util import rmtree


def path_to_url(path):
Example #17
0
class TestPipEnvironment(TestFileEnvironment):
    """A specialized TestFileEnvironment for testing pip"""

    #
    # Attribute naming convention
    # ---------------------------
    #
    # Instances of this class have many attributes representing paths
    # in the filesystem.  To keep things straight, absolute paths have
    # a name of the form xxxx_path and relative paths have a name that
    # does not end in '_path'.

    # The following paths are relative to the root_path, and should be
    # treated by clients as instance attributes.  The fact that they
    # are defined in the class is an implementation detail

    # where we'll create the virtual Python installation for testing
    #
    # Named with a leading dot to reduce the chance of spurious
    # results due to being mistaken for the virtualenv package.
    venv = Path('.virtualenv')

    # The root of a directory tree to be used arbitrarily by tests
    scratch = Path('scratch')

    exe = sys.platform == 'win32' and '.exe' or ''

    verbose = False

    def __init__(self, environ=None, use_distribute=None):

        self.root_path = Path(tempfile.mkdtemp('-piptest'))

        # We will set up a virtual environment at root_path.
        self.scratch_path = self.root_path / self.scratch

        self.venv_path = self.root_path / self.venv

        if not environ:
            environ = os.environ.copy()
            environ = clear_environ(environ)
            environ['PIP_DOWNLOAD_CACHE'] = str(download_cache)

        environ['PIP_NO_INPUT'] = '1'
        environ['PIP_LOG_FILE'] = str(self.root_path / 'pip-log.txt')

        super(TestPipEnvironment, self).__init__(self.root_path,
                                                 ignore_hidden=False,
                                                 environ=environ,
                                                 split_cmd=False,
                                                 start_clear=False,
                                                 cwd=self.scratch_path,
                                                 capture_temp=True,
                                                 assert_no_temp=True)

        demand_dirs(self.venv_path)
        demand_dirs(self.scratch_path)

        if use_distribute is None:
            use_distribute = os.environ.get('PIP_TEST_USE_DISTRIBUTE', False)

        # Create a virtualenv and remember where it's putting things.
        virtualenv_paths = create_virtualenv(self.venv_path,
                                             distribute=use_distribute)

        assert self.venv_path == virtualenv_paths[0]  # sanity check

        for id, path in zip(('venv', 'lib', 'include', 'bin'),
                            virtualenv_paths):
            setattr(self, id + '_path', Path(path))
            setattr(self, id, relpath(self.root_path, path))

        assert self.venv == TestPipEnvironment.venv  # sanity check

        self.site_packages = self.lib / 'site-packages'
        self.user_base_path = self.venv_path / 'user'
        self.user_site_path = self.venv_path / 'user' / 'lib' / self.lib.name / 'site-packages'

        self.user_site = relpath(self.root_path, self.user_site_path)
        demand_dirs(self.user_site_path)
        self.environ["PYTHONUSERBASE"] = self.user_base_path

        # create easy-install.pth in user_site, so we always have it updated instead of created
        open(self.user_site_path / 'easy-install.pth', 'w').close()

        # put the test-scratch virtualenv's bin dir first on the PATH
        self.environ['PATH'] = Path.pathsep.join(
            (self.bin_path, self.environ['PATH']))

        # test that test-scratch virtualenv creation produced sensible venv python
        result = self.run('python', '-c', 'import sys; print(sys.executable)')
        pythonbin = result.stdout.strip()

        if Path(pythonbin).noext != self.bin_path / 'python':
            raise RuntimeError("Oops! 'python' in our test environment runs %r"
                               " rather than expected %r" %
                               (pythonbin, self.bin_path / 'python'))

        # make sure we have current setuptools to avoid svn incompatibilities
        if not use_distribute:
            install_setuptools(self)

        # Uninstall whatever version of pip came with the virtualenv.
        # Earlier versions of pip were incapable of
        # self-uninstallation on Windows, so we use the one we're testing.
        self.run(
            'python', '-c',
            '"import sys; sys.path.insert(0, %r); import pip; sys.exit(pip.main());"'
            % os.path.dirname(here), 'uninstall', '-vvv', '-y', 'pip')

        # Install this version instead
        self.run('python',
                 'setup.py',
                 'install',
                 cwd=src_folder,
                 expect_stderr=True)
        self._use_cached_pypi_server()

    def _ignore_file(self, fn):
        if fn.endswith('__pycache__') or fn.endswith(".pyc"):
            result = True
        else:
            result = super(TestPipEnvironment, self)._ignore_file(fn)
        return result

    def run(self, *args, **kw):
        if self.verbose:
            print('>> running %s %s' % (args, kw))
        cwd = kw.pop('cwd', None)
        run_from = kw.pop('run_from', None)
        assert not cwd or not run_from, "Don't use run_from; it's going away"
        cwd = Path.string(cwd or run_from or self.cwd)
        assert not isinstance(cwd, Path)
        return TestPipResult(super(TestPipEnvironment, self).run(cwd=cwd,
                                                                 *args,
                                                                 **kw),
                             verbose=self.verbose)

    def __del__(self):
        rmtree(str(self.root_path), ignore_errors=True)

    def _use_cached_pypi_server(self):
        site_packages = self.root_path / self.site_packages
        pth = open(os.path.join(site_packages, 'pypi_intercept.pth'), 'w')
        pth.write('import sys; ')
        pth.write('sys.path.insert(0, %r); ' % str(here))
        pth.write('import pypi_server; pypi_server.PyPIProxy.setup(); ')
        pth.write('sys.path.remove(%r); ' % str(here))
        pth.close()
Example #18
0
from pip.backwardcompat import urllib

from pip.req import InstallRequirement
from pip.index import PackageFinder

from tests.path import Path
from tests.test_pip import here

find_links = 'file://' + urllib.quote(
    str(Path(here).abspath / 'packages').replace('\\', '/'))


def test_no_mpkg():
    """Finder skips zipfiles with "macosx10" in the name."""
    finder = PackageFinder([find_links], [])
    req = InstallRequirement.from_line("pkgwithmpkg")
    found = finder.find_requirement(req, False)

    assert found.url.endswith("pkgwithmpkg-1.0.tar.gz"), found


def test_no_partial_name_match():
    """Finder requires the full project name to match, not just beginning."""
    finder = PackageFinder([find_links], [])
    req = InstallRequirement.from_line("gmpy")
    found = finder.find_requirement(req, False)

    assert found.url.endswith("gmpy-1.15.tar.gz"), found
Example #19
0
    def assert_installed(self, pkg_name, with_files=[], without_files=[], without_egg_link=False, use_user_site=False):
        e = self.test_env

        pkg_dir = e.venv/ 'src'/ pkg_name.lower()

        if use_user_site:
            egg_link_path = e.user_site / pkg_name + '.egg-link'
        else:
            egg_link_path = e.site_packages / pkg_name + '.egg-link'
        if without_egg_link:
            if egg_link_path in self.files_created:
                raise TestFailure('unexpected egg link file created: '\
                                  '%r\n%s' % (egg_link_path, self))
        else:
            if not egg_link_path in self.files_created:
                raise TestFailure('expected egg link file missing: '\
                                  '%r\n%s' % (egg_link_path, self))

            egg_link_file = self.files_created[egg_link_path]

            if not (# FIXME: I don't understand why there's a trailing . here
                    egg_link_file.bytes.endswith('.')
                and egg_link_file.bytes[:-1].strip().endswith(pkg_dir)):
                raise TestFailure(textwrap.dedent(u('''\
                Incorrect egg_link file %r
                Expected ending: %r
                ------- Actual contents -------
                %s
                -------------------------------''' % (
                        egg_link_file,
                        pkg_dir + u('\n.'),
                        egg_link_file.bytes))))

        if use_user_site:
            pth_file = Path.string(e.user_site / 'easy-install.pth')
        else:
            pth_file = Path.string(e.site_packages / 'easy-install.pth')

        if (pth_file in self.files_updated) == without_egg_link:
            raise TestFailure('%r unexpectedly %supdated by install' % (
                pth_file, (not without_egg_link and 'not ' or '')))

        if (pkg_dir in self.files_created) == (curdir in without_files):
            raise TestFailure(textwrap.dedent('''\
            expected package directory %r %sto be created
            actually created:
            %s
            ''') % (
                Path.string(pkg_dir),
                (curdir in without_files and 'not ' or ''),
                sorted(self.files_created.keys())))

        for f in with_files:
            if not (pkg_dir/f).normpath in self.files_created:
                raise TestFailure('Package directory %r missing '\
                                  'expected content %f' % (pkg_dir, f))

        for f in without_files:
            if (pkg_dir/f).normpath in self.files_created:
                raise TestFailure('Package directory %r has '\
                                  'unexpected content %f' % (pkg_dir, f))
from pip.backwardcompat import urllib
from tests.test_pip import here, reset_env, run_pip, pyversion
from tests.path import Path

index_url = 'file://' + urllib.quote(
    str(Path(here).abspath / 'in dex').replace('\\', '/'))


def test_install():
    """
    Test installing from a local index.

    """
    env = reset_env()
    result = run_pip('install',
                     '-vvv',
                     '--index-url',
                     index_url,
                     'FSPkg',
                     expect_error=False)
    assert (env.site_packages / 'fspkg') in result.files_created, str(
        result.stdout)
    assert (env.site_packages / 'FSPkg-0.1dev-py%s.egg-info' %
            pyversion) in result.files_created, str(result)
Example #21
0
    def assert_installed(self,
                         pkg_name,
                         with_files=[],
                         without_files=[],
                         without_egg_link=False,
                         use_user_site=False):
        e = self.test_env

        pkg_dir = e.venv / 'src' / pkg_name.lower()

        if use_user_site:
            egg_link_path = e.user_site / pkg_name + '.egg-link'
        else:
            egg_link_path = e.site_packages / pkg_name + '.egg-link'
        if without_egg_link:
            if egg_link_path in self.files_created:
                raise TestFailure('unexpected egg link file created: '\
                                  '%r\n%s' % (egg_link_path, self))
        else:
            if not egg_link_path in self.files_created:
                raise TestFailure('expected egg link file missing: '\
                                  '%r\n%s' % (egg_link_path, self))

            egg_link_file = self.files_created[egg_link_path]

            if not (  # FIXME: I don't understand why there's a trailing . here
                    egg_link_file.bytes.endswith('.')
                    and egg_link_file.bytes[:-1].strip().endswith(pkg_dir)):
                raise TestFailure(
                    textwrap.dedent(
                        u('''\
                Incorrect egg_link file %r
                Expected ending: %r
                ------- Actual contents -------
                %s
                -------------------------------''' %
                          (egg_link_file, pkg_dir + u('\n.'),
                           egg_link_file.bytes))))

        if use_user_site:
            pth_file = Path.string(e.user_site / 'easy-install.pth')
        else:
            pth_file = Path.string(e.site_packages / 'easy-install.pth')

        if (pth_file in self.files_updated) == without_egg_link:
            raise TestFailure('%r unexpectedly %supdated by install' %
                              (pth_file,
                               (not without_egg_link and 'not ' or '')))

        if (pkg_dir in self.files_created) == (curdir in without_files):
            raise TestFailure(
                textwrap.dedent('''\
            expected package directory %r %sto be created
            actually created:
            %s
            ''') % (Path.string(pkg_dir),
                    (curdir in without_files and 'not '
                     or ''), sorted(self.files_created.keys())))

        for f in with_files:
            if not (pkg_dir / f).normpath in self.files_created:
                raise TestFailure('Package directory %r missing '\
                                  'expected content %f' % (pkg_dir, f))

        for f in without_files:
            if (pkg_dir / f).normpath in self.files_created:
                raise TestFailure('Package directory %r has '\
                                  'unexpected content %f' % (pkg_dir, f))